diff --git a/nb-configuration.xml b/nb-configuration.xml
new file mode 100644
index 0000000..29f9746
--- /dev/null
+++ b/nb-configuration.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project-shared-configuration>
+    <!--
+This file contains additional configuration written by modules in the NetBeans IDE.
+The configuration is intended to be shared among all the users of project and
+therefore it is assumed to be part of version control checkout.
+Without this configuration present, some functionality in the IDE may be limited or fail altogether.
+-->
+    <properties xmlns="http://www.netbeans.org/ns/maven-properties-data/1">
+        <!--
+Properties that influence various parts of the IDE, especially code formatting and the like. 
+You can copy and paste the single properties, into the pom.xml file and the IDE will pick them up.
+That way multiple projects can share the same settings (useful for formatting rules for example).
+Any value defined here will override the pom.xml file value but is only applicable to the current project.
+-->
+        <org-netbeans-modules-html-editor-lib.default-html-public-id>HTML5</org-netbeans-modules-html-editor-lib.default-html-public-id>
+    </properties>
+</project-shared-configuration>
diff --git a/pom.xml b/pom.xml
index 0cc66c9..c425eec 100644
--- a/pom.xml
+++ b/pom.xml
@@ -39,14 +39,14 @@
                         <phase>package</phase>
                         <goals>
                             <goal>jar</goal>
-                        </goals>
+                        </goals>                        
                     </execution>
                 </executions>            
             </plugin>
 <!--            <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-dependency-plugin</artifactId>
-                <version>2.6</version>
+                <version>2.10</version>
                 <executions>
                     <execution>
                         <id>unpack-dependencies</id>
@@ -141,5 +141,16 @@
             <artifactId>reflections</artifactId>
             <version>0.9.9</version>
         </dependency>
+        <dependency>
+            <groupId>megacz</groupId>
+            <artifactId>nestedvm</artifactId>
+            <version>2014.12.3</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.10</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>
diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store
index 2323e46..a83bb29 100644
Binary files a/src/main/java/.DS_Store and b/src/main/java/.DS_Store differ
diff --git a/src/main/java/jace/EmulatorUILogic.java b/src/main/java/jace/EmulatorUILogic.java
index c8bcbf1..e7fffcf 100644
--- a/src/main/java/jace/EmulatorUILogic.java
+++ b/src/main/java/jace/EmulatorUILogic.java
@@ -30,6 +30,7 @@ import jace.core.Debugger;
 import jace.core.RAM;
 import jace.core.RAMListener;
 import static jace.core.Utility.*;
+import jace.ide.IdeController;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
@@ -374,6 +375,28 @@ public class EmulatorUILogic implements Reconfigurable {
             throw new RuntimeException(exception);
         }
     }
+    
+    @InvokableAction(
+            name = "Open IDE",
+            category = "development",
+            description = "Open new IDE window for Basic/Assembly/Plasma coding",
+            alternatives = "dev,development,acme,assembler,editor",
+            defaultKeyMapping = {"ctrl+shift+i"})
+    public static void showIDE() {
+        FXMLLoader fxmlLoader = new FXMLLoader(EmulatorUILogic.class.getResource("/fxml/editor.fxml"));
+        fxmlLoader.setResources(null);
+        try {
+            Stage editorWindow = new Stage();
+            AnchorPane node = (AnchorPane) fxmlLoader.load();
+            IdeController controller = fxmlLoader.getController();
+            controller.initialize();
+            Scene s = new Scene(node);
+            editorWindow.setScene(s);
+            editorWindow.show();
+        } catch (IOException exception) {
+            throw new RuntimeException(exception);
+        }
+    }
 
     public static boolean confirm(String message) {
 //        return JOptionPane.YES_OPTION == JOptionPane.showConfirmDialog(Emulator.getFrame(), message);
diff --git a/src/main/java/jace/JaceUIController.java b/src/main/java/jace/JaceUIController.java
index b7519ea..a47344d 100644
--- a/src/main/java/jace/JaceUIController.java
+++ b/src/main/java/jace/JaceUIController.java
@@ -7,7 +7,6 @@
 package jace;
 
 import com.sun.glass.ui.Application;
-import com.sun.org.apache.xerces.internal.util.URI;
 import jace.core.Card;
 import jace.core.Computer;
 import jace.library.MediaCache;
@@ -16,6 +15,7 @@ import jace.library.MediaConsumerParent;
 import jace.library.MediaEntry;
 import java.io.File;
 import java.io.IOException;
+import java.net.URI;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -95,9 +95,10 @@ public class JaceUIController {
             media = MediaCache.getMediaFromUrl(evt.getDragboard().getUrl());
         } else if (evt.getDragboard().hasString()) {
             String path = evt.getDragboard().getString();
-            if (URI.isWellFormedAddress(path)) {
+            try {
+                URI.create(path);
                 media = MediaCache.getMediaFromUrl(path);
-            } else {
+            } catch (IllegalArgumentException ex) {
                 File f = new File(path);
                 if (f.exists()) {
                     media = MediaCache.getMediaFromFile(f);
diff --git a/src/main/java/jace/apple2e/MOS65C02.java b/src/main/java/jace/apple2e/MOS65C02.java
index 355cfe2..200a569 100644
--- a/src/main/java/jace/apple2e/MOS65C02.java
+++ b/src/main/java/jace/apple2e/MOS65C02.java
@@ -785,8 +785,7 @@ public class MOS65C02 extends CPU {
             cpu.setProgramCounter(address);
         }),
         JSR((address, value, addressMode, cpu) -> {
-            cpu.pushWord(cpu.getProgramCounter() - 1);
-            cpu.setProgramCounter(address);
+            cpu.JSR(address);
         }),
         LDA((address, value, addressMode, cpu) -> {
             cpu.A = value;
@@ -1165,6 +1164,12 @@ public class MOS65C02 extends CPU {
         suspend();
     }
 
+    @Override
+    public void JSR(int address) {
+            pushWord(getProgramCounter() - 1);
+            setProgramCounter(address);
+    }
+
     public void BRK() {
         if (isLogEnabled()) {
             System.out.println("BRK at $" + Integer.toString(getProgramCounter(), 16));
diff --git a/src/main/java/jace/applesoft/ApplesoftHandler.java b/src/main/java/jace/applesoft/ApplesoftHandler.java
new file mode 100644
index 0000000..a261816
--- /dev/null
+++ b/src/main/java/jace/applesoft/ApplesoftHandler.java
@@ -0,0 +1,29 @@
+package jace.applesoft;
+
+import jace.Emulator;
+import jace.ide.Program;
+import jace.ide.CompileResult;
+import jace.ide.LanguageHandler;
+
+/**
+ *
+ * @author blurry
+ */
+public class ApplesoftHandler implements LanguageHandler<Program> {
+
+    @Override
+    public String getNewDocumentContent() {
+        return ApplesoftProgram.fromMemory(Emulator.computer.getMemory()).toString();
+    }
+
+    @Override
+    public CompileResult<Program> compile(Program program) {
+        return null;
+    }
+
+    @Override
+    public void execute(CompileResult<Program> lastResult) {
+        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+    }
+    
+}
diff --git a/src/main/java/jace/applesoft/ApplesoftProgram.java b/src/main/java/jace/applesoft/ApplesoftProgram.java
new file mode 100755
index 0000000..7475239
--- /dev/null
+++ b/src/main/java/jace/applesoft/ApplesoftProgram.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2012 Brendan Robert (BLuRry) brendan.robert@gmail.com.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301  USA
+ */
+package jace.applesoft;
+
+import jace.core.RAM;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Decode an applesoft program into a list of program lines Right now this is an
+ * example/test program but it successfully tokenized the source of Lemonade
+ * Stand.
+ *
+ * @author Brendan Robert (BLuRry) brendan.robert@gmail.com
+ */
+public class ApplesoftProgram {
+
+    List<Line> lines = new ArrayList<>();
+    public static final int startingAddressPointer = 0x067;
+    int startingAddress = 0x0801;
+
+    public static void main(String... args) {
+        byte[] source = null;
+        try {
+            File f = new File("/home/brobert/Documents/Personal/a2gameserver/lib/data/games/LEMONADE#fc0801");
+            FileInputStream in = new FileInputStream(f);
+            source = new byte[(int) f.length()];
+            in.read(source);
+        } catch (FileNotFoundException ex) {
+            Logger.getLogger(ApplesoftProgram.class.getName()).log(Level.SEVERE, null, ex);
+        } catch (IOException ex) {
+            Logger.getLogger(ApplesoftProgram.class.getName()).log(Level.SEVERE, null, ex);
+        }
+        ApplesoftProgram test = ApplesoftProgram.fromBinary(Arrays.asList(toObjects(source)));
+        System.out.println(test.toString());
+    }
+
+    public static Byte[] toObjects(byte[] bytesPrim) {
+        Byte[] bytes = new Byte[bytesPrim.length];
+        Arrays.setAll(bytes, n -> bytesPrim[n]);
+        return bytes;
+    }
+
+    public static ApplesoftProgram fromBinary(List<Byte> binary) {
+        return fromBinary(binary, 0x0801);
+    }
+
+    public static ApplesoftProgram fromMemory(RAM memory) {
+        int startAddress = memory.readWordRaw(startingAddressPointer);
+        int nextCheck = memory.readWordRaw(startAddress);
+        int pos = startAddress;
+        List<Byte> bytes = new ArrayList<>();
+        while (nextCheck != 0) {
+            while (pos < nextCheck + 2) {
+                bytes.add(memory.readRaw(pos++));
+            }
+            nextCheck = memory.readWordRaw(nextCheck);
+        }
+        return fromBinary(bytes, startAddress);
+    }
+
+    public static ApplesoftProgram fromBinary(List<Byte> binary, int startAddress) {
+        ApplesoftProgram program = new ApplesoftProgram();
+        int currentAddress = startAddress;
+        int pos = 0;
+        while (pos < binary.size()) {
+            int nextAddress = (binary.get(pos) & 0x0ff) + ((binary.get(pos + 1) & 0x0ff) << 8);
+            if (nextAddress == 0) {
+                break;
+            }
+            int length = nextAddress - currentAddress;
+            Line l = Line.fromBinary(binary, pos);
+            if (l == null) {
+                break;
+            }
+            program.lines.add(l);
+            if (l.getLength() != length) {
+                System.out.println("Line " + l.getNumber() + " parsed as " + l.getLength() + " bytes long, but that leaves "
+                        + (length - l.getLength()) + " bytes hidden behind next line");
+            }
+            pos += length;
+            currentAddress = nextAddress;
+        }
+        return program;
+    }
+
+    @Override
+    public String toString() {
+        String out = "";
+        out = lines.stream().map((l) -> l.toString() + "\n").reduce(out, String::concat);
+        return out;
+    }
+}
diff --git a/src/main/java/jace/applesoft/Line.java b/src/main/java/jace/applesoft/Line.java
index 78a0f97..3926b58 100755
--- a/src/main/java/jace/applesoft/Line.java
+++ b/src/main/java/jace/applesoft/Line.java
@@ -31,7 +31,7 @@ public class Line {
     private int number;
     private Line next;
     private Line previous;
-    private List<Command> commands = new ArrayList<Command>();
+    private List<Command> commands = new ArrayList<>();
     private int length;
 
     /**
@@ -116,20 +116,20 @@ public class Line {
         return out;
     }
 
-    static Line fromBinary(byte[] binary, int pos) {
+    static Line fromBinary(List<Byte> binary, int pos) {
         Line l = new Line();
-        int lineNumber = (binary[pos+2] & 0x0ff) + ((binary[pos+3] & 0x0ff) << 8);
+        int lineNumber = (binary.get(pos+2) & 0x0ff) + ((binary.get(pos+3) & 0x0ff) << 8);
         l.setNumber(lineNumber);
         pos += 4;
         Command c = new Command();
         int size = 5;
-        while (binary[pos] != 0) {
+        while (binary.get(pos) != 0) {
             size++;
-            if (binary[pos] == STATEMENT_BREAK) {
+            if (binary.get(pos) == STATEMENT_BREAK) {
                 l.commands.add(c);
                 c = new Command();
             } else {
-                Command.ByteOrToken bt = new Command.ByteOrToken(binary[pos]);
+                Command.ByteOrToken bt = new Command.ByteOrToken(binary.get(pos));
                 c.parts.add(bt);
             }
             pos++;
diff --git a/src/main/java/jace/applesoft/Program.java b/src/main/java/jace/applesoft/Program.java
deleted file mode 100755
index 0753b5c..0000000
--- a/src/main/java/jace/applesoft/Program.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2012 Brendan Robert (BLuRry) brendan.robert@gmail.com.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301  USA
- */
-package jace.applesoft;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/**
- * Decode an applesoft program into a list of program lines
- * Right now this is an example/test program but it successfully tokenized the
- * souce of Lemonade Stand.
- * @author Brendan Robert (BLuRry) brendan.robert@gmail.com 
- */
-public class Program {
-    List<Line> lines = new ArrayList<Line>();
-    int startingAddress = 0x0801;
-
-    public static void main(String... args) {
-        byte[] source = null;
-        try {
-            File f = new File("/home/brobert/Documents/Personal/a2gameserver/lib/data/games/LEMONADE#fc0801");
-            FileInputStream in = new FileInputStream(f);
-            source = new byte[(int) f.length()];
-            in.read(source);
-        } catch (FileNotFoundException ex) {
-            Logger.getLogger(Program.class.getName()).log(Level.SEVERE, null, ex);
-        } catch (IOException ex) {
-            Logger.getLogger(Program.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        Program test = Program.fromBinary(source);
-        System.out.println(test.toString());
-    }
-
-    static Program fromBinary(byte[] binary) {
-        return fromBinary(binary, 0x0801);
-    }
-
-    static Program fromBinary(byte[] binary, int startAddress) {
-        Program program = new Program();
-        int currentAddress = startAddress;
-        int pos = 0;
-        while (pos < binary.length) {
-            int nextAddress = (binary[pos] & 0x0ff) + ((binary[pos+1] & 0x0ff) << 8);
-            if (nextAddress == 0) break;
-            int length = nextAddress - currentAddress;
-            Line l = Line.fromBinary(binary, pos);
-            if (l == null) break;
-            program.lines.add(l);
-            if (l.getLength() != length) {
-                System.out.println("Line "+l.getNumber()+" parsed as "+l.getLength()+" bytes long, but that leaves "+
-                        (length - l.getLength())+" bytes hidden behind next line");
-            }
-            pos += length;
-            currentAddress = nextAddress;
-        }
-        return program;
-    }
-
-    @Override
-    public String toString() {
-        String out = "";
-        for (Line l : lines)
-            out += l.toString() + "\n";
-        return out;
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/jace/assembly/AcmeCompiler.java b/src/main/java/jace/assembly/AcmeCompiler.java
new file mode 100644
index 0000000..44b28d4
--- /dev/null
+++ b/src/main/java/jace/assembly/AcmeCompiler.java
@@ -0,0 +1,120 @@
+package jace.assembly;
+
+import jace.ide.Program;
+import jace.ide.CompileResult;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+/**
+ *
+ * @author blurry
+ */
+public class AcmeCompiler implements CompileResult<File> {
+
+    boolean successful = false;
+    File compiledAsset = null;
+    Map<Integer, String> errorsAndWarnings = new LinkedHashMap<>();
+    List<String> otherWarnings = new ArrayList<>();
+    List<String> rawOutput = new ArrayList<>();
+
+    @Override
+    public boolean isSuccessful() {
+        return successful;
+    }
+
+    @Override
+    public File getCompiledAsset() {
+        return compiledAsset;
+    }
+
+    @Override
+    public Map<Integer, String> getErrorsAndWarnings() {
+        return errorsAndWarnings;
+    }
+
+    @Override
+    public List<String> getOtherMessages() {
+        return otherWarnings;
+    }
+
+    @Override
+    public List<String> getRawOutput() {
+        return rawOutput;
+    }
+
+    public void compile(Program proxy) {
+        File workingDirectory = proxy.getFile()
+                .map(file -> file.getParentFile())
+                .orElse(new File(System.getProperty("user.dir")));
+        File sourceFile = new File(workingDirectory, "_acme_tmp_" + ((int) (Math.random() * 1024.0)) + ".a");
+        try (FileWriter writer = new FileWriter(sourceFile)) {
+            writer.append(proxy.getValue());
+            writer.flush();
+            writer.close();
+            invokeAcme(sourceFile, workingDirectory);
+        } catch (Exception ex) {
+            compilationFailure(ex);
+        } finally {
+            sourceFile.delete();            
+        }
+    }
+
+    private void compilationFailure(Exception ex) {
+        Logger.getLogger(AcmeCompiler.class.getName()).log(Level.SEVERE, null, ex);
+        rawOutput = Arrays.asList(ex.getStackTrace()).stream().map(element -> element.toString()).collect(Collectors.toList());
+        otherWarnings = rawOutput;
+    }
+
+    PrintStream systemOut = System.out;
+    PrintStream systemErr = System.err;
+    ByteArrayOutputStream baosOut;
+    PrintStream out;
+    ByteArrayOutputStream baosErr;
+    PrintStream err;
+
+    private void invokeAcme(File sourceFile, File workingDirectory) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IOException {
+        String oldPath = System.getProperty("user.dir");
+        redirectSystemOutput();
+        try {
+            compiledAsset = File.createTempFile(sourceFile.getName(), "bin", sourceFile.getParentFile());
+            System.setProperty("user.dir", workingDirectory.getAbsolutePath());
+            AcmeCrossAssembler acme = new AcmeCrossAssembler();
+            String[] params = {"--outfile", compiledAsset.getAbsolutePath(), "-f", "cbm", "--maxerrors","16",sourceFile.getAbsolutePath()};
+            int status = acme.run("Acme", params);
+            successful = status == 0;
+        } finally {
+            restoreSystemOutput();
+            System.setProperty("user.dir", oldPath);
+        }
+        String output = baosOut.toString();
+        String errors = baosErr.toString();
+        System.out.println("output: "+output);
+        System.out.println("error: "+errors);
+        
+    }
+
+    public void restoreSystemOutput() {
+        System.setOut(systemOut);
+        System.setErr(systemErr);
+    }
+
+    public void redirectSystemOutput() {
+        baosOut = new ByteArrayOutputStream();
+        out = new PrintStream(baosOut);
+        baosErr = new ByteArrayOutputStream();
+        err = new PrintStream(baosErr);
+        System.setOut(out);
+        System.setErr(err);
+    }
+}
diff --git a/src/main/java/jace/assembly/AcmeCrossAssembler.java b/src/main/java/jace/assembly/AcmeCrossAssembler.java
new file mode 100644
index 0000000..2f2bed8
--- /dev/null
+++ b/src/main/java/jace/assembly/AcmeCrossAssembler.java
@@ -0,0 +1,92142 @@
+package jace.assembly;
+/* This file was generated from acme by Mips2Java on Tue Jul 14 00:46:52 CDT 2015 */
+
+public final class AcmeCrossAssembler extends org.ibex.nestedvm.UnixRuntime {
+    /* program counter */
+    private int pc = 0;
+
+    /* General Purpose registers */
+    private final static int r0 = 0;
+    private int      r1,  r2,  r3,  r4,  r5,  r6,  r7,
+                r8,  r9,  r10, r11, r12, r13, r14, r15,
+                r16, r17, r18, r19, r20, r21, r22, r23,
+                r24, r25, r26, r27, r28, r29, r30, r31,
+                hi = 0, lo = 0;
+    /* FP registers */
+    private int f0,  f1,  f2,  f3,  f4,  f5,  f6,  f7,
+                f8,  f9,  f10, f11, f12, f13, f14, f15,
+                f16, f17, f18, f19, f20, f21, f22, f23,
+                f24, f25, f26, f27, f28, f29, f30, f31;
+    /* FP Control Register */
+    private int fcsr = 0;
+
+    private final void run_10000() throws ExecutionException { /* 0x10000 - 0x10200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x10000:
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r0 >= 0) {
+                        /* Next insn is delay slot */ 
+                        r31=0x10010;
+                        pc=0x10010;
+                        continue;
+                    }
+                case 0x10010:
+                    /* Next insn is delay slot */ 
+                    r31=0x10018;
+                    pc=0x101ac;
+                    continue;
+                case 0x10018:
+                    if(r0 >= 0) {
+                        /* Next insn is delay slot */ 
+                        r31=0x10020;
+                        pc=0x10020;
+                        continue;
+                    }
+                case 0x10020:
+                    /* Next insn is delay slot */ 
+                    r31=0x10028;
+                    pc=0x10208;
+                    run_10200(); return;
+                case 0x10028:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x10038:
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r0 >= 0) {
+                        /* Next insn is delay slot */ 
+                        r31=0x10048;
+                        pc=0x10048;
+                        continue;
+                    }
+                case 0x10048:
+                    /* Next insn is delay slot */ 
+                    r31=0x10050;
+                    pc=0x100e4;
+                    continue;
+                case 0x10050:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x10060:
+                    r4 = 7 << 16;
+                    r2 = 7 << 16;
+                    r4 = r4 + 12296;
+                    r2 = r2 + 12299;
+                    r2 = r2 - r4;
+                    r2 = (r2&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        r25 = 0 << 16;
+                        pc=0x10088;
+                        continue;
+                    }
+                    r25 = 0 << 16;
+                case 0x10080:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x10088:
+                    r25 = r25 + 0;
+                    if(r25 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10080;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x1009c:
+                    r4 = 7 << 16;
+                    r2 = 7 << 16;
+                    r4 = r4 + 12296;
+                    r2 = r2 + 12296;
+                    r2 = r2 - r4;
+                    r2 = r2 >> 2;
+                    r3 = r2 >>> 31;
+                    r2 = r3 + r2;
+                    r5 = r2 >> 1;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        r25 = 0 << 16;
+                        pc=0x100d0;
+                        continue;
+                    }
+                    r25 = 0 << 16;
+                case 0x100c8:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x100d0:
+                    r25 = r25 + 0;
+                    if(r25 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x100c8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x100e4:
+                    r29 = r29 + -40;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r19 = 7 << 16;
+                    addr=r19+14512;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                        pc=0x10190;
+                        continue;
+                    }
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r18 = 7 << 16;
+                    r17 = 7 << 16;
+                    r18 = r18 + -14840;
+                    r17 = r17 + -14836;
+                    r16 = 7 << 16;
+                    r17 = r17 - r18;
+                    r2 = readPages[(r16+14516)>>>12][((r16+14516)>>>2)&0x3ff];
+                    r17 = r17 >> 2;
+                    r17 = r17 + -1;
+                    r3 = ((r2 & 0xffffffffL) < (r17 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        r2 = r2 + 1;
+                        pc=0x10164;
+                        continue;
+                    }
+                    r2 = r2 + 1;
+                case 0x10138:
+                    r3 = r2 << 2;
+                    r3 = r18 + r3;
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    writePages[(r16+14516)>>>12][((r16+14516)>>>2)&0x3ff] = r2;
+                    pc=r3;
+                    r31=0x10150;
+                    return;
+                case 0x10150:
+                    r2 = readPages[(r16+14516)>>>12][((r16+14516)>>>2)&0x3ff];
+                    r3 = ((r2 & 0xffffffffL) < (r17 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        r2 = r2 + 1;
+                        pc=0x10138;
+                        continue;
+                    }
+                    r2 = r2 + 1;
+                case 0x10164:
+                    /* Next insn is delay slot */ 
+                    r31=0x1016c;
+                    pc=0x10060;
+                    continue;
+                case 0x1016c:
+                    r2 = 0 << 16;
+                    r2 = r2 + 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        r2 = r0 + 1;
+                        pc=0x1018c;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    r4 = 7 << 16;
+                    /* Next insn is delay slot */ 
+                    r4 = r4 + 5436;
+                    r31=0x10188;
+                    pc=0x0;
+                    throw new ExecutionException("Branch to addr 0x0");
+                case 0x10188:
+                    r2 = r0 + 1;
+                case 0x1018c:
+                    addr=r19+14512;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x10190:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r29 = r29 + 40;
+                    pc=r31;
+                    return;
+                case 0x101ac:
+                    r2 = 0 << 16;
+                    r29 = r29 + -24;
+                    r2 = r2 + 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                        pc=0x101d4;
+                        continue;
+                    }
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r4 = 7 << 16;
+                    r5 = 7 << 16;
+                    r4 = r4 + 5436;
+                    /* Next insn is delay slot */ 
+                    r5 = r5 + 14520;
+                    r31=0x101d4;
+                    pc=0x0;
+                    throw new ExecutionException("Branch to addr 0x0");
+                case 0x101d4:
+                    r4 = 7 << 16;
+                    r2 = readPages[(r4+5440)>>>12][((r4+5440)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        r2 = 0 << 16;
+                        pc=0x101fc;
+                        continue;
+                    }
+                    r2 = 0 << 16;
+                    r2 = r2 + 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x101fc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r4 = r4 + 5440;
+                    pc=r2;
+                    r31=0x101fc;
+                    return;
+                case 0x101fc:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                case 0x10200:
+                    pc=0x10200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_10200() throws ExecutionException { /* 0x10200 - 0x10400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x10200:
+                    /* Next insn is delay slot */ 
+                    r29 = r29 + 24;
+                    pc=0x1009c;
+                    run_10000(); return;
+                case 0x10208:
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+-14848)>>>12][((r2+-14848)>>>2)&0x3ff];
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10260;
+                        continue;
+                    }
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = 7 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r16 + -14852;
+                    r17 = r0 + -1;
+                case 0x10238:
+                    /* Next insn is delay slot */ 
+                    r16 = r16 + -4;
+                    pc=r2;
+                    r31=0x10240;
+                    return;
+                case 0x10240:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    if(r2 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10238;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                case 0x10260:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x10268:
+                    r2 = r4 + 1;
+                case 0x1026c:
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        r4 = r4 + 1;
+                        pc=0x1026c;
+                        continue;
+                    }
+                    r4 = r4 + 1;
+                    /* Next insn is delay slot */ 
+                    r2 = r4 - r2;
+                    pc=r31;
+                    return;
+                case 0x10284:
+                    r29 = r29 + -32;
+                    r2 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    r7 = r16 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x102ac;
+                    return;
+                case 0x102ac:
+                    r3 = r2 + r0;
+                    r2 = r0 + 2;
+                    pc = 0x102b4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x102b8;
+                        return;
+                    }
+                case 0x102b8:
+                    r2 = r0 + 1;
+                    r3 = r0 + 1;
+                    pc = 0x102c0;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x102c4;
+                        return;
+                    }
+                case 0x102c4:
+                case 0x10400:
+                    pc=0x10400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_10400() throws ExecutionException { /* 0x10400 - 0x10600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x10400:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r28 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1047c;
+                        continue;
+                    }
+                case 0x10418:
+                    writePages[(r28+-31080)>>>12][((r28+-31080)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x10424;
+                    pc=0x10000;
+                    run_10000(); return;
+                case 0x10424:
+                    r4 = 1 << 16;
+                    r4 = r4 + 56;
+                    /* Next insn is delay slot */ 
+                    r31=0x10434;
+                    pc=0x38a00;
+                    run_38a00(); return;
+                case 0x10434:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1048c;
+                        continue;
+                    }
+                    r2 = r16 + 4;
+                    r4 = r0 + r0;
+                case 0x1044c:
+                    r2 = r2 + 4;
+                    r6 = readPages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1044c;
+                        continue;
+                    }
+                case 0x10460:
+                    r6 = readPages[(r28+-31080)>>>12][((r28+-31080)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10470;
+                    pc=0x11c00;
+                    run_11c00(); return;
+                case 0x10470:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1047c;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x1047c:
+                    r2 = 8 << 16;
+                    r28 = r2 + -20464;
+                    /* Next insn is delay slot */ 
+                    pc=0x10418;
+                    continue;
+                case 0x1048c:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x10460;
+                    continue;
+                case 0x10600:
+                    pc=0x10600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_10600() throws ExecutionException { /* 0x10600 - 0x10800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x10600:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r4 + r0;
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    r29 = r29 + -24;
+                    r5 = r5 + -12288;
+                    r6 = r6 + -7904;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x1062c;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1062c:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x10638;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x10638:
+                case 0x10800:
+                    pc=0x10800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_10800() throws ExecutionException { /* 0x10800 - 0x10a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x10800:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    r29 = r29 + -24;
+                    r5 = r5 + -12260;
+                    r6 = r6 + -7904;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x10828;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x10828:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x10834;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x10834:
+                case 0x10a00:
+                    pc=0x10a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_10a00() throws ExecutionException { /* 0x10a00 - 0x10c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x10a00:
+                    r4 = 7 << 16;
+                    r29 = r29 + -24;
+                    r4 = r4 + -12200;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x10a18;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x10a18:
+                    r4 = 7 << 16;
+                    r4 = r4 + -12104;
+                    /* Next insn is delay slot */ 
+                    r31=0x10a28;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x10a28:
+                    r4 = 7 << 16;
+                    r4 = r4 + -12016;
+                    /* Next insn is delay slot */ 
+                    r31=0x10a38;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x10a38:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10a44;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x10a44:
+                case 0x10c00:
+                    pc=0x10c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_10c00() throws ExecutionException { /* 0x10c00 - 0x10e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x10c00:
+                    r29 = r29 + -64;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r21;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r20;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r19;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r18;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r17;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r16 = r4 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10d7c;
+                        continue;
+                    }
+                    r21 = 7 << 16;
+                    r20 = 7 << 16;
+                    r18 = 7 << 16;
+                    r21 = r21 + -9536;
+                    r20 = r20 + -9308;
+                    r19 = 7 << 16;
+                    r18 = r18 + -9268;
+                    r17 = 7 << 16;
+                case 0x10c50:
+                    r3 = r2 + -68;
+                    r3 = r3 & 255;
+                    r5 = (r3&0xffffffffL) < (51&0xffffffffL) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10d10;
+                        continue;
+                    }
+                    r3 = r3 << 2;
+                    r3 = r21 + r3;
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    return;
+                case 0x10c7c:
+                    r16 = r18 + r0;
+                case 0x10c80:
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10f34;
+                        run_10e00(); return;
+                    }
+                    r3 = r0 + 37;
+                    r4 = r16 + 1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10f4c;
+                        run_10e00(); return;
+                    }
+                    r3 = r0 + 38;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10f94;
+                        run_10e00(); return;
+                    }
+                    r3 = r0 + 36;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10fa4;
+                        run_10e00(); return;
+                    }
+                    r3 = r0 + 48;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10f5c;
+                        run_10e00(); return;
+                    }
+                case 0x10cc4:
+                    r6 = r0 + 10;
+                case 0x10cc8:
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x10cd4;
+                    pc=0x43600;
+                    run_43600(); return;
+                case 0x10cd4:
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r16 = r2 + r0;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10fb4;
+                        run_10e00(); return;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x10d00;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x10d00:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10d0c;
+                    pc=0x30200;
+                    run_30200(); return;
+                case 0x10d0c:
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                case 0x10d10:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r21 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r20 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r19 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r18 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r17 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r16 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x10d38:
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff] = r2;
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r2 + -48;
+                    r4 = r3 & 255;
+                    r4 = (r4&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10d70;
+                        continue;
+                    }
+                    writePages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff] = r3;
+                    addr=r16+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r16 = r16 + 1;
+                case 0x10d70:
+                    r16 = r16 + 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10c50;
+                        continue;
+                    }
+                case 0x10d7c:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x10d10;
+                    continue;
+                case 0x10d88:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = r0 + 61;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r18 = r16 + 1;
+                    if(r5 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10c7c;
+                        continue;
+                    }
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10f34;
+                        run_10e00(); return;
+                    }
+                    r4 = r2 + r0;
+                    r16 = r18 + r0;
+                    r17 = r0 + 61;
+                    /* Next insn is delay slot */ 
+                    pc=0x10dcc;
+                    continue;
+                case 0x10dc0:
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10f34;
+                        run_10e00(); return;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                case 0x10dcc:
+                    r16 = r16 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x10dd8;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x10dd8:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    if(r5 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10dc0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x10c80;
+                    continue;
+                case 0x10df0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -12104;
+                    /* Next insn is delay slot */ 
+                    r31=0x10e00;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x10e00:
+                    pc=0x10e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_10e00() throws ExecutionException { /* 0x10e00 - 0x11000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x10e00:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10e0c;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x10e0c:
+                    /* Next insn is delay slot */ 
+                    r31=0x10e14;
+                    pc=0x10a00;
+                    run_10a00(); return;
+                case 0x10e14:
+                    r4 = r19 + -9292;
+                    /* Next insn is delay slot */ 
+                    r31=0x10e20;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x10e20:
+                    writePages[(r28+-30840)>>>12][((r28+-30840)>>>2)&0x3ff] = r2;
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x10d70;
+                    run_10c00(); return;
+                case 0x10e30:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10e3c;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x10e3c:
+                    writePages[(r28+-30848)>>>12][((r28+-30848)>>>2)&0x3ff] = r2;
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x10d70;
+                    run_10c00(); return;
+                case 0x10e4c:
+                    r4 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10e58;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x10e58:
+                    writePages[(r28+-30852)>>>12][((r28+-30852)>>>2)&0x3ff] = r2;
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x10d70;
+                    run_10c00(); return;
+                case 0x10e68:
+                    r16 = r16 + 1;
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10396;
+                    /* Next insn is delay slot */ 
+                    r31=0x10e80;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x10e80:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10f40;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10380;
+                    /* Next insn is delay slot */ 
+                    r31=0x10e9c;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x10e9c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10f88;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10368;
+                    /* Next insn is delay slot */ 
+                    r31=0x10eb8;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x10eb8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10fc4;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r28+-30740)>>>12][((r28+-30740)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x10d10;
+                    run_10c00(); return;
+                case 0x10ed4:
+                    r4 = r17 + -10412;
+                    /* Next insn is delay slot */ 
+                    r31=0x10ee0;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x10ee0:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r2 + r0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10ef4;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x10ef4:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10f04;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x10f04:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10f18;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x10f18:
+                    /* Next insn is delay slot */ 
+                    r31=0x10f20;
+                    pc=0x26800;
+                    run_26800(); return;
+                case 0x10f20:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10fbc;
+                        continue;
+                    }
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x10d70;
+                    run_10c00(); return;
+                case 0x10f34:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x10f40;
+                    pc=0x10600;
+                    run_10600(); return;
+                case 0x10f40:
+                    writePages[(r28+-32332)>>>12][((r28+-32332)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x10d10;
+                    run_10c00(); return;
+                case 0x10f4c:
+                    r4 = r16 + 2;
+                    r6 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x10cc8;
+                    run_10c00(); return;
+                case 0x10f5c:
+                    addr=r16+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r0 + 88;
+                    r3 = r3 & 223;
+                    r3 = r3 << 24;
+                    r3 = r3 >> 24;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x10cc4;
+                        run_10c00(); return;
+                    }
+                    r4 = r16 + 3;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x10cc8;
+                    run_10c00(); return;
+                case 0x10f88:
+                    writePages[(r28+-32336)>>>12][((r28+-32336)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x10d10;
+                    run_10c00(); return;
+                case 0x10f94:
+                    r4 = r16 + 2;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x10cc8;
+                    run_10c00(); return;
+                case 0x10fa4:
+                    r4 = r16 + 2;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x10cc8;
+                    run_10c00(); return;
+                case 0x10fb4:
+                    /* Next insn is delay slot */ 
+                    r31=0x10fbc;
+                    pc=0x10600;
+                    run_10600(); return;
+                case 0x10fbc:
+                    /* Next insn is delay slot */ 
+                    r31=0x10fc4;
+                    pc=0x10800;
+                    run_10800(); return;
+                case 0x10fc4:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    r5 = r5 + -10352;
+                    r6 = r6 + -7904;
+                    /* Next insn is delay slot */ 
+                    r31=0x10fe4;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x10fe4:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x10ff0;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x10ff0:
+                case 0x11000:
+                    pc=0x11000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_11000() throws ExecutionException { /* 0x11000 - 0x11200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x11000:
+                    r5 = 7 << 16;
+                    r29 = r29 + -32;
+                    r5 = r5 + -10324;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11020;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x11020:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11730;
+                        run_11600(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10316;
+                    /* Next insn is delay slot */ 
+                    r31=0x1103c;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x1103c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11218;
+                        run_11200(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10308;
+                    /* Next insn is delay slot */ 
+                    r31=0x11058;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x11058:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1128c;
+                        run_11200(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10300;
+                    /* Next insn is delay slot */ 
+                    r31=0x11074;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x11074:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x111dc;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10288;
+                    /* Next insn is delay slot */ 
+                    r31=0x11090;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x11090:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x111dc;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10276;
+                    /* Next insn is delay slot */ 
+                    r31=0x110ac;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x110ac:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x112ac;
+                        run_11200(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10264;
+                    /* Next insn is delay slot */ 
+                    r31=0x110c8;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x110c8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x112cc;
+                        run_11200(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10256;
+                    /* Next insn is delay slot */ 
+                    r31=0x110e4;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x110e4:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x112ec;
+                        run_11200(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10188;
+                    /* Next insn is delay slot */ 
+                    r31=0x11100;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x11100:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x113c8;
+                        run_11200(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10108;
+                    /* Next insn is delay slot */ 
+                    r31=0x1111c;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x1111c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11430;
+                        run_11400(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10044;
+                    /* Next insn is delay slot */ 
+                    r31=0x11138;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x11138:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x114f8;
+                        run_11400(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -10012;
+                    /* Next insn is delay slot */ 
+                    r31=0x11154;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x11154:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x115a4;
+                        run_11400(); return;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -9984;
+                    /* Next insn is delay slot */ 
+                    r31=0x11170;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x11170:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x111fc;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -9972;
+                    /* Next insn is delay slot */ 
+                    r31=0x1118c;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x1118c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x111c8;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -9964;
+                    /* Next insn is delay slot */ 
+                    r31=0x111a8;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x111a8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11654;
+                        run_11600(); return;
+                    }
+                case 0x111b0:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x111c8:
+                    r2 = r0 + 1;
+                    writePages[(r28+-30748)>>>12][((r28+-30748)>>>2)&0x3ff] = r2;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    continue;
+                case 0x111dc:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9292;
+                    /* Next insn is delay slot */ 
+                    r31=0x111ec;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x111ec:
+                    writePages[(r28+-30840)>>>12][((r28+-30840)>>>2)&0x3ff] = r2;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    continue;
+                case 0x111fc:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                case 0x11200:
+                    pc=0x11200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_11200() throws ExecutionException { /* 0x11200 - 0x11400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x11200:
+                    r16 = r0 + r0;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    run_11000(); return;
+                case 0x11218:
+                    r4 = 7 << 16;
+                    r4 = r4 + -10412;
+                    /* Next insn is delay slot */ 
+                    r31=0x11228;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x11228:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r2 + r0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1123c;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x1123c:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1124c;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1124c:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11260;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x11260:
+                    /* Next insn is delay slot */ 
+                    r31=0x11268;
+                    pc=0x26800;
+                    run_26800(); return;
+                case 0x11268:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11738;
+                        run_11600(); return;
+                    }
+                case 0x11270:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = r0 + r0;
+                    r2 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1128c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9268;
+                    /* Next insn is delay slot */ 
+                    r31=0x1129c;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x1129c:
+                    writePages[(r28+-30848)>>>12][((r28+-30848)>>>2)&0x3ff] = r2;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    run_11000(); return;
+                case 0x112ac:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9332;
+                    /* Next insn is delay slot */ 
+                    r31=0x112bc;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x112bc:
+                    writePages[(r28+-30844)>>>12][((r28+-30844)>>>2)&0x3ff] = r2;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    run_11000(); return;
+                case 0x112cc:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9308;
+                    /* Next insn is delay slot */ 
+                    r31=0x112dc;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x112dc:
+                    writePages[(r28+-30852)>>>12][((r28+-30852)>>>2)&0x3ff] = r2;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    run_11000(); return;
+                case 0x112ec:
+                    r4 = 7 << 16;
+                    r4 = r4 + -10248;
+                    /* Next insn is delay slot */ 
+                    r31=0x112fc;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x112fc:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r4 = r0 + 37;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11670;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 38;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x116b0;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 36;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x116f0;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 48;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1139c;
+                        continue;
+                    }
+                case 0x11330:
+                    r6 = r0 + 10;
+                case 0x11334:
+                    r4 = r2 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x11344;
+                    pc=0x43600;
+                    run_43600(); return;
+                case 0x11344:
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11740;
+                        run_11600(); return;
+                    }
+                    r3 = 1 << 16;
+                    writePages[(r28+-32752)>>>12][((r28+-32752)>>>2)&0x3ff] = r2;
+                    r2 = ((r2 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11270;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r5 = r5 + -10232;
+                case 0x11380:
+                    r6 = 7 << 16;
+                    r6 = r6 + -7904;
+                    /* Next insn is delay slot */ 
+                    r31=0x11390;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x11390:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x1139c;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x1139c:
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r3 = r0 + 88;
+                    r4 = r4 & 223;
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11330;
+                        continue;
+                    }
+                    r2 = r2 + 2;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x11334;
+                    continue;
+                case 0x113c8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -10184;
+                    /* Next insn is delay slot */ 
+                    r31=0x113d8;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x113d8:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r2 + r0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x113ec;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x113ec:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x113fc;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x113fc:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                case 0x11400:
+                    pc=0x11400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_11400() throws ExecutionException { /* 0x11400 - 0x11600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x11400:
+                    r5 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11410;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x11410:
+                    /* Next insn is delay slot */ 
+                    r31=0x11418;
+                    pc=0x17000;
+                    run_17000(); return;
+                case 0x11418:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11748;
+                        run_11600(); return;
+                    }
+                    writePages[(r28+-30836)>>>12][((r28+-30836)>>>2)&0x3ff] = r2;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    run_11000(); return;
+                case 0x11430:
+                    r4 = 7 << 16;
+                    r4 = r4 + -10100;
+                    /* Next insn is delay slot */ 
+                    r31=0x11440;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x11440:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r4 = r0 + 37;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11680;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 38;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x116c0;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 36;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11700;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 48;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x114cc;
+                        continue;
+                    }
+                case 0x11474:
+                    r6 = r0 + 10;
+                case 0x11478:
+                    r4 = r2 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x11488;
+                    pc=0x43600;
+                    run_43600(); return;
+                case 0x11488:
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11740;
+                        run_11600(); return;
+                    }
+                    writePages[(r28+-32756)>>>12][((r28+-32756)>>>2)&0x3ff] = r2;
+                    r2 = r2 + 128;
+                    r2 = (r2&0xffffffffL) < (384&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11270;
+                        run_11200(); return;
+                    }
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r5 = r5 + -10084;
+                    /* Next insn is delay slot */ 
+                    pc=0x11380;
+                    run_11200(); return;
+                case 0x114cc:
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r3 = r0 + 88;
+                    r4 = r4 & 223;
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11474;
+                        continue;
+                    }
+                    r2 = r2 + 2;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x11478;
+                    continue;
+                case 0x114f8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -10032;
+                    /* Next insn is delay slot */ 
+                    r31=0x11508;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x11508:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r4 = r0 + 37;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11690;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 38;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x116d0;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 36;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11710;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 48;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11578;
+                        continue;
+                    }
+                case 0x1153c:
+                    r6 = r0 + 10;
+                case 0x11540:
+                    r4 = r2 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x11550;
+                    pc=0x43600;
+                    run_43600(); return;
+                case 0x11550:
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11740;
+                        run_11600(); return;
+                    }
+                    writePages[(r28+-32340)>>>12][((r28+-32340)>>>2)&0x3ff] = r2;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    run_11000(); return;
+                case 0x11578:
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r3 = r0 + 88;
+                    r4 = r4 & 223;
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1153c;
+                        continue;
+                    }
+                    r2 = r2 + 2;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x11540;
+                    continue;
+                case 0x115a4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -10000;
+                    /* Next insn is delay slot */ 
+                    r31=0x115b4;
+                    pc=0x16a00;
+                    run_16a00(); return;
+                case 0x115b4:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r4 = r0 + 37;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x116a0;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 38;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x116e0;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 36;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11720;
+                        run_11600(); return;
+                    }
+                    r4 = r0 + 48;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11628;
+                        run_11600(); return;
+                    }
+                case 0x115e8:
+                    r6 = r0 + 10;
+                case 0x115ec:
+                    r4 = r2 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x115fc;
+                    pc=0x43600;
+                    run_43600(); return;
+                case 0x115fc:
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x11600:
+                    pc=0x11600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_11600() throws ExecutionException { /* 0x11600 - 0x11800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x11600:
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11740;
+                        continue;
+                    }
+                    writePages[(r28+-32764)>>>12][((r28+-32764)>>>2)&0x3ff] = r2;
+                    writePages[(r28+-32760)>>>12][((r28+-32760)>>>2)&0x3ff] = r2;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x111b0;
+                    run_11000(); return;
+                case 0x11628:
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r3 = r0 + 88;
+                    r4 = r4 & 223;
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x115e8;
+                        run_11400(); return;
+                    }
+                    r2 = r2 + 2;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x115ec;
+                    run_11400(); return;
+                case 0x11654:
+                    r4 = 7 << 16;
+                    r4 = r4 + -12104;
+                    /* Next insn is delay slot */ 
+                    r31=0x11664;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x11664:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11670;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x11670:
+                    r2 = r2 + 1;
+                    r6 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x11334;
+                    run_11200(); return;
+                case 0x11680:
+                    r2 = r2 + 1;
+                    r6 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x11478;
+                    run_11400(); return;
+                case 0x11690:
+                    r2 = r2 + 1;
+                    r6 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x11540;
+                    run_11400(); return;
+                case 0x116a0:
+                    r2 = r2 + 1;
+                    r6 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x115ec;
+                    run_11400(); return;
+                case 0x116b0:
+                    r2 = r2 + 1;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x11334;
+                    run_11200(); return;
+                case 0x116c0:
+                    r2 = r2 + 1;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x11478;
+                    run_11400(); return;
+                case 0x116d0:
+                    r2 = r2 + 1;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x11540;
+                    run_11400(); return;
+                case 0x116e0:
+                    r2 = r2 + 1;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x115ec;
+                    run_11400(); return;
+                case 0x116f0:
+                    r2 = r2 + 1;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x11334;
+                    run_11200(); return;
+                case 0x11700:
+                    r2 = r2 + 1;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x11478;
+                    run_11400(); return;
+                case 0x11710:
+                    r2 = r2 + 1;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x11540;
+                    run_11400(); return;
+                case 0x11720:
+                    r2 = r2 + 1;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x115ec;
+                    run_11400(); return;
+                case 0x11730:
+                    /* Next insn is delay slot */ 
+                    r31=0x11738;
+                    pc=0x10a00;
+                    run_10a00(); return;
+                case 0x11738:
+                    /* Next insn is delay slot */ 
+                    r31=0x11740;
+                    pc=0x10800;
+                    run_10800(); return;
+                case 0x11740:
+                    /* Next insn is delay slot */ 
+                    r31=0x11748;
+                    pc=0x10600;
+                    run_10600(); return;
+                case 0x11748:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r5 = r5 + -10172;
+                    /* Next insn is delay slot */ 
+                    pc=0x11380;
+                    run_11200(); return;
+                case 0x11800:
+                    pc=0x11800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_11800() throws ExecutionException { /* 0x11800 - 0x11a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x11800:
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1183c;
+                        continue;
+                    }
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1183c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x11838;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x11838:
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r0;
+                case 0x1183c:
+                    r4 = readPages[(r28+-30840)>>>12][((r28+-30840)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1187c;
+                        continue;
+                    }
+                    r5 = r28 + -32744;
+                    /* Next insn is delay slot */ 
+                    r31=0x11858;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x11858:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11914;
+                        continue;
+                    }
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11870;
+                    pc=0x30400;
+                    run_30400(); return;
+                case 0x11870:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1187c;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x1187c:
+                    r4 = readPages[(r28+-30844)>>>12][((r28+-30844)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x118bc;
+                        continue;
+                    }
+                    r5 = r28 + -32744;
+                    /* Next insn is delay slot */ 
+                    r31=0x11898;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x11898:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x118d8;
+                        continue;
+                    }
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x118b0;
+                    pc=0x30600;
+                    run_30600(); return;
+                case 0x118b0:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x118bc;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x118bc:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r17 + r0;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x118d8:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30844)>>>12][((r28+-30844)>>>2)&0x3ff];
+                    r5 = r5 + -9912;
+                    /* Next insn is delay slot */ 
+                    r31=0x118f4;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x118f4:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = r0 + 1;
+                    r2 = r17 + r0;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x11914:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30840)>>>12][((r28+-30840)>>>2)&0x3ff];
+                    r5 = r5 + -9956;
+                    /* Next insn is delay slot */ 
+                    r31=0x11930;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x11930:
+                    r17 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1187c;
+                    continue;
+                case 0x11a00:
+                    pc=0x11a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_11a00() throws ExecutionException { /* 0x11a00 - 0x11c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x11a00:
+                    r29 = r29 + -40;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x11a20;
+                    pc=0x27600;
+                    run_27600(); return;
+                case 0x11a20:
+                    r4 = readPages[(r28+-30836)>>>12][((r28+-30836)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x11a2c;
+                    pc=0x17400;
+                    run_17400(); return;
+                case 0x11a2c:
+                    r4 = readPages[(r28+-32752)>>>12][((r28+-32752)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11a48;
+                        continue;
+                    }
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11a48;
+                    pc=0x27e00;
+                    run_27e00(); return;
+                case 0x11a48:
+                    /* Next insn is delay slot */ 
+                    r31=0x11a50;
+                    pc=0x18e00;
+                    run_18e00(); return;
+                case 0x11a50:
+                    /* Next insn is delay slot */ 
+                    r31=0x11a58;
+                    pc=0x2e800;
+                    run_2e800(); return;
+                case 0x11a58:
+                    r2 = readPages[(r28+-30832)>>>12][((r28+-30832)>>>2)&0x3ff];
+                    writePages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff] = r0;
+                    writePages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff] = r0;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11b34;
+                        continue;
+                    }
+                    r18 = 7 << 16;
+                    r19 = 7 << 16;
+                    r16 = r0 + r0;
+                    r18 = r18 + 12832;
+                    r19 = r19 + -9864;
+                    /* Next insn is delay slot */ 
+                    pc=0x11ab8;
+                    continue;
+                case 0x11a88:
+                    r3 = readPages[(r28+-30828)>>>12][((r28+-30828)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    r17 = r3 + r17;
+                    r5 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x11aa4;
+                    pc=0x19c00;
+                    run_19c00(); return;
+                case 0x11aa4:
+                    r2 = readPages[(r28+-30832)>>>12][((r28+-30832)>>>2)&0x3ff];
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11b24;
+                        continue;
+                    }
+                case 0x11ab8:
+                    r2 = readPages[(r28+-30828)>>>12][((r28+-30828)>>>2)&0x3ff];
+                    r17 = r16 << 2;
+                    r2 = r2 + r17;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11ad4;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x11ad4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11a88;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30828)>>>12][((r28+-30828)>>>2)&0x3ff];
+                    r5 = r19 + r0;
+                    r17 = r2 + r17;
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x11b00;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x11b00:
+                    r2 = readPages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30832)>>>12][((r28+-30832)>>>2)&0x3ff];
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11ab8;
+                        continue;
+                    }
+                case 0x11b24:
+                    r2 = readPages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11b60;
+                        continue;
+                    }
+                case 0x11b34:
+                    /* Next insn is delay slot */ 
+                    r31=0x11b3c;
+                    pc=0x27800;
+                    run_27800(); return;
+                case 0x11b3c:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x11b60:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x11b6c;
+                    pc=0x11800;
+                    run_11800(); return;
+                case 0x11b6c:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11b78;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x11b78:
+                case 0x11c00:
+                    pc=0x11c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_11c00() throws ExecutionException { /* 0x11c00 - 0x11e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x11c00:
+                    r29 = r29 + -32;
+                    r2 = r0 + 1;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11f10;
+                        run_11e00(); return;
+                    }
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r2 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    writePages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x11c38;
+                    pc=0x16c00;
+                    run_16c00(); return;
+                case 0x11c38:
+                    /* Next insn is delay slot */ 
+                    r31=0x11c40;
+                    pc=0x18200;
+                    run_18200(); return;
+                case 0x11c40:
+                    /* Next insn is delay slot */ 
+                    r31=0x11c48;
+                    pc=0x28600;
+                    run_28600(); return;
+                case 0x11c48:
+                    r4 = 1 << 16;
+                    r5 = 1 << 16;
+                    r4 = r4 + 3072;
+                    r5 = r5 + 4096;
+                    /* Next insn is delay slot */ 
+                    r31=0x11c60;
+                    pc=0x16800;
+                    run_16800(); return;
+                case 0x11c60:
+                    r6 = 7 << 16;
+                    r5 = r28 + -30828;
+                    r6 = r6 + -9824;
+                    r4 = r28 + -30832;
+                    /* Next insn is delay slot */ 
+                    r31=0x11c78;
+                    pc=0x16e00;
+                    run_16e00(); return;
+                case 0x11c78:
+                    /* Next insn is delay slot */ 
+                    r31=0x11c80;
+                    pc=0x15800;
+                    run_15800(); return;
+                case 0x11c80:
+                    /* Next insn is delay slot */ 
+                    r31=0x11c88;
+                    pc=0x20400;
+                    run_20400(); return;
+                case 0x11c88:
+                    /* Next insn is delay slot */ 
+                    r31=0x11c90;
+                    pc=0x22400;
+                    run_22400(); return;
+                case 0x11c90:
+                    r4 = readPages[(r28+-32756)>>>12][((r28+-32756)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x11c9c;
+                    pc=0x26e00;
+                    run_26e00(); return;
+                case 0x11c9c:
+                    /* Next insn is delay slot */ 
+                    r31=0x11ca4;
+                    pc=0x2e000;
+                    run_2e000(); return;
+                case 0x11ca4:
+                    r3 = 7 << 16;
+                    r2 = r3 + 14544;
+                    writePages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff] = r2;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    writePages[(r3+14544)>>>12][((r3+14544)>>>2)&0x3ff] = r0;
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11ce0;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -9796;
+                    /* Next insn is delay slot */ 
+                    r31=0x11ce0;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x11ce0:
+                    writePages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11cec;
+                    pc=0x11a00;
+                    run_11a00(); return;
+                case 0x11cec:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11d58;
+                        continue;
+                    }
+                    r17 = 7 << 16;
+                    r17 = r17 + -9784;
+                    /* Next insn is delay slot */ 
+                    pc=0x11d18;
+                    continue;
+                case 0x11d08:
+                    r16 = r2 < r16 ? 1 : 0;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11e50;
+                        run_11e00(); return;
+                    }
+                    r16 = r2 + r0;
+                case 0x11d18:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11d48;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11d48;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x11d48:
+                    /* Next insn is delay slot */ 
+                    r31=0x11d50;
+                    pc=0x11a00;
+                    run_11a00(); return;
+                case 0x11d50:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11d08;
+                        continue;
+                    }
+                case 0x11d58:
+                    r16 = readPages[(r28+-30852)>>>12][((r28+-30852)>>>2)&0x3ff];
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11df4;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11d90;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -9768;
+                    /* Next insn is delay slot */ 
+                    r31=0x11d8c;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x11d8c:
+                    r16 = readPages[(r28+-30852)>>>12][((r28+-30852)>>>2)&0x3ff];
+                case 0x11d90:
+                    r17 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r5 = r28 + -32744;
+                    /* Next insn is delay slot */ 
+                    r31=0x11da4;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x11da4:
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11ea0;
+                        run_11e00(); return;
+                    }
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x11dc8;
+                    pc=0x11a00;
+                    run_11a00(); return;
+                case 0x11dc8:
+                    r16 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11df4;
+                        continue;
+                    }
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11df4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x11df0;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x11df0:
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r0;
+                case 0x11df4:
+                    r4 = readPages[(r28+-30848)>>>12][((r28+-30848)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11ec4;
+                        run_11e00(); return;
+                    }
+                case 0x11e00:
+                    pc=0x11e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_11e00() throws ExecutionException { /* 0x11e00 - 0x12000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x11e00:
+                    r5 = r28 + -32748;
+                    /* Next insn is delay slot */ 
+                    r31=0x11e10;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x11e10:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11eec;
+                        continue;
+                    }
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11e28;
+                    pc=0x27000;
+                    run_27000(); return;
+                case 0x11e28:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11e34;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x11e34:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x11800;
+                    run_11800(); return;
+                case 0x11e50:
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x11e74;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -9688;
+                    /* Next insn is delay slot */ 
+                    r31=0x11e74;
+                    pc=0x40400;
+                    run_40400(); return;
+                case 0x11e74:
+                    r2 = 2 << 16;
+                    r2 = r2 + -20480;
+                    writePages[(r28+-30824)>>>12][((r28+-30824)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x11e98;
+                    pc=0x11a00;
+                    run_11a00(); return;
+                case 0x11e98:
+                    /* Next insn is delay slot */ 
+                    pc=0x11e34;
+                    continue;
+                case 0x11ea0:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r5 = r5 + -9728;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x11ebc;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x11ebc:
+                    /* Next insn is delay slot */ 
+                    pc=0x11df4;
+                    run_11c00(); return;
+                case 0x11ec4:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r7 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r4 + -9652;
+                    r5 = r0 + 1;
+                    r6 = r0 + 75;
+                    /* Next insn is delay slot */ 
+                    r31=0x11ee4;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x11ee4:
+                    /* Next insn is delay slot */ 
+                    pc=0x11e34;
+                    continue;
+                case 0x11eec:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30848)>>>12][((r28+-30848)>>>2)&0x3ff];
+                    r5 = r5 + -9576;
+                    /* Next insn is delay slot */ 
+                    r31=0x11f08;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x11f08:
+                    /* Next insn is delay slot */ 
+                    pc=0x11e34;
+                    continue;
+                case 0x11f10:
+                    /* Next insn is delay slot */ 
+                    r31=0x11f18;
+                    pc=0x10a00;
+                    run_10a00(); return;
+                case 0x11f18:
+                case 0x12000:
+                    pc=0x12000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_12000() throws ExecutionException { /* 0x12000 - 0x12200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x12000:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r16 = r16 + r2;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r3 = r2 & 256;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x120b0;
+                        continue;
+                    }
+                    f12 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    f13 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                case 0x12044:
+                    f0 = readPages[(r28+-32404)>>>12][((r28+-32404)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32408)>>>12][((r28+-32408)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<=(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12084;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-32396)>>>12][((r28+-32396)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32400)>>>12][((r28+-32400)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))<=(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12104;
+                        continue;
+                    }
+                case 0x12084:
+                    r2 = r2 & 16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x120d0;
+                        continue;
+                    }
+                case 0x12090:
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r0;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                case 0x12098:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r0;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x120b0:
+                    f0 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 | 256;
+                    { long l = Double.doubleToLongBits(((double)f0)); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = f12;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = f13;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x12044;
+                    continue;
+                case 0x120d0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9252;
+                    /* Next insn is delay slot */ 
+                    r31=0x120e0;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x120e0:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r2 = r2 + -24;
+                    r16 = r16 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x12090;
+                    continue;
+                case 0x12104:
+                    /* Next insn is delay slot */ 
+                    pc=r4;
+                    r31=0x1210c;
+                    return;
+                case 0x1210c:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = f0;
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = f1;
+                    r2 = r2 - r3;
+                    r16 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r16 = r16 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x12098;
+                    continue;
+                case 0x12200:
+                    pc=0x12200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_12200() throws ExecutionException { /* 0x12200 - 0x12400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x12200:
+                    r29 = r29 + -40;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    r18 = r5 + r0;
+                    r5 = r0 + 32;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    r17 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1222c;
+                    pc=0x2f400;
+                    run_2f400(); return;
+                case 0x1222c:
+                    r16 = r2 + r0;
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r19 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x122d4;
+                        continue;
+                    }
+                case 0x12250:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12270;
+                        continue;
+                    }
+                    r2 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r2;
+                case 0x12270:
+                    r17 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r2 = r17 << 3;
+                    r3 = r17 << 5;
+                    r3 = r3 - r2;
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r6 = r0 + 24;
+                    r3 = r2 + r3;
+                    r4 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1229c;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x1229c:
+                    r3 = r2 + r0;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = r17 + 1;
+                    r2 = r2 | 64;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r17;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x122d4:
+                    r4 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12328;
+                        continue;
+                    }
+                case 0x122e8:
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x122f4;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x122f4:
+                    r4 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r5 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = ((r5 & 0xffffffffL) < (r17 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12344;
+                        continue;
+                    }
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r17;
+                case 0x12314:
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x12320;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x12320:
+                    /* Next insn is delay slot */ 
+                    pc=0x12250;
+                    continue;
+                case 0x12328:
+                    r5 = r0 + 46;
+                    /* Next insn is delay slot */ 
+                    r31=0x12334;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x12334:
+                    r17 = r17 + 1;
+                    r4 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x122e8;
+                    continue;
+                case 0x12344:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9228;
+                    r5 = r5 - r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x12358;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x12358:
+                    r4 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x12314;
+                    continue;
+                case 0x12400:
+                    pc=0x12400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_12400() throws ExecutionException { /* 0x12400 - 0x12600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x12400:
+                    r29 = r29 + -136;
+                    writePages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff] = f20;
+                    writePages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff] = f21;
+                    f20 = readPages[(r28+-32396)>>>12][((r28+-32396)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r2;
+                    f21 = readPages[(r28+-32400)>>>12][((r28+-32400)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r23;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r19;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r18;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r17;
+                    r23 = r28 + -32444;
+                    r19 = 7 << 16;
+                    r18 = 7 << 16;
+                    r17 = 7 << 16;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r22;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r21;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r20;
+                    writePages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff] = f22;
+                    writePages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff] = f23;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r31;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r30;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r16;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = f28;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = f29;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = f26;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = f27;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = f24;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = f25;
+                    r21 = r4 + r0;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r0;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r0;
+                    writePages[(r28+-30808)>>>12][((r28+-30808)>>>2)&0x3ff] = r0;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r23;
+                    r22 = r0 + 1;
+                    r20 = r0 + r0;
+                    r19 = r19 + -7236;
+                    r18 = r18 + -8652;
+                    f22 = f20;
+                    f23 = f21;
+                    r17 = r17 + -8284;
+                case 0x124a4:
+                    r5 = readPages[(r28+-32736)>>>12][((r28+-32736)>>>2)&0x3ff];
+                    r22 = r22 < r5 ? 1 : 0;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x125fc;
+                        continue;
+                    }
+                case 0x124b8:
+                    r2 = readPages[(r28+-32740)>>>12][((r28+-32740)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r3 < r2 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12648;
+                        run_12600(); return;
+                    }
+                case 0x124d0:
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12694;
+                        run_12600(); return;
+                    }
+                case 0x124e0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x126d4;
+                        run_12600(); return;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x125d8;
+                        continue;
+                    }
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r2 = r22 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12720;
+                        run_12600(); return;
+                    }
+                    r2 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r3 = r22 << 2;
+                    r3 = r3 + -8;
+                    r16 = r2 + r3;
+                    r3 = r3 + 4;
+                    r2 = r2 + r3;
+                    r6 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r30 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    addr=r6+4;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    addr=r30+4;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r3 = r4 < r5 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12720;
+                        run_12600(); return;
+                    }
+                    if(r4 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12714;
+                        run_12600(); return;
+                    }
+                case 0x12548:
+                    r5 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r3 = (r5&0xffffffffL) < (38&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1435c;
+                        run_14200(); return;
+                    }
+                    r4 = 7 << 16;
+                    r3 = r5 << 2;
+                    r4 = r4 + -8804;
+                    r3 = r4 + r3;
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    return;
+                case 0x1257c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x143c4;
+                        run_14200(); return;
+                    }
+                case 0x1258c:
+                    r2 = r2 & 255;
+                    r2 = r19 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13338;
+                        run_13200(); return;
+                    }
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13314;
+                        run_13200(); return;
+                    }
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = r28 + -32644;
+                    r2 = r22 + 1;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r22 = r22 << 2;
+                    r2 = r2 + r22;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                case 0x125d8:
+                    r3 = (r2&0xffffffffL) < (3&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1275c;
+                        run_12600(); return;
+                    }
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-32736)>>>12][((r28+-32736)>>>2)&0x3ff];
+                    r22 = r22 < r5 ? 1 : 0;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x124b8;
+                        continue;
+                    }
+                case 0x125fc:
+                    r4 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                case 0x12600:
+                    pc=0x12600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_12600() throws ExecutionException { /* 0x12600 - 0x12800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x12600:
+                    r2 = r5 << 1;
+                    r5 = r5 << 3;
+                    writePages[(r28+-32736)>>>12][((r28+-32736)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x12614;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x12614:
+                    writePages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x124b8;
+                        run_12400(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    /* Next insn is delay slot */ 
+                    r31=0x12630;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x12630:
+                    r2 = readPages[(r28+-32740)>>>12][((r28+-32740)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r3 < r2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x124d0;
+                        run_12400(); return;
+                    }
+                case 0x12648:
+                    r3 = r2 << 1;
+                    r5 = r2 << 4;
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 << 6;
+                    r5 = r2 - r5;
+                    writePages[(r28+-32740)>>>12][((r28+-32740)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x12668;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x12668:
+                    writePages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x124d0;
+                        run_12400(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    /* Next insn is delay slot */ 
+                    r31=0x12684;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x12684:
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x124e0;
+                        run_12400(); return;
+                    }
+                case 0x12694:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x129b8;
+                        run_12800(); return;
+                    }
+                    r3 = r2 + r0;
+                case 0x126a8:
+                    r2 = r3 + -33;
+                    r2 = r2 & 255;
+                    r4 = (r2&0xffffffffL) < (92&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13038;
+                        run_13000(); return;
+                    }
+                    r2 = r2 << 2;
+                    r2 = r18 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x126d4:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x129cc;
+                        run_12800(); return;
+                    }
+                    r22 = r2 + r0;
+                case 0x126e8:
+                    r2 = r22 + -33;
+                    r2 = r2 & 255;
+                    r3 = (r2&0xffffffffL) < (62&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12804;
+                        run_12800(); return;
+                    }
+                    r2 = r2 << 2;
+                    r2 = r17 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x12714:
+                    r4 = r4 & 1;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12548;
+                        run_12400(); return;
+                    }
+                case 0x12720:
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x124a4;
+                    run_12400(); return;
+                case 0x1272c:
+                    /* Next insn is delay slot */ 
+                    r31=0x12734;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12734:
+                    r3 = r0 + 61;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x131a8;
+                        run_13000(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x12750;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x12750:
+                    r2 = r0 + 4;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 4;
+                case 0x1275c:
+                    r3 = r0 + 5;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x128a4;
+                        run_12800(); return;
+                    }
+                case 0x12768:
+                    f28 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    f26 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    f24 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    f22 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    f20 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    r31 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r2 = r20 + r0;
+                    r30 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r23 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r22 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r21 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r20 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r19 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r18 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r17 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r16 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    f29 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    f27 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    f25 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    f23 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    f21 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x127c8:
+                    r16 = r28 + -32596;
+                case 0x127cc:
+                    /* Next insn is delay slot */ 
+                    r31=0x127d4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x127d4:
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 + r0;
+                    r2 = r2 << 2;
+                    r2 = r3 + r2;
+                    r22 = r22 + 1;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r16;
+                    r2 = r0 + 2;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r22;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x124a4;
+                    run_12400(); return;
+                case 0x12800:
+                    pc=0x12800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_12800() throws ExecutionException { /* 0x12800 - 0x12a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x12800:
+                case 0x12804:
+                    r22 = r22 & 255;
+                    r2 = r22 + -48;
+                    r2 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13370;
+                        run_13200(); return;
+                    }
+                    r22 = r19 + r22;
+                    addr=r22+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1445c;
+                        run_14400(); return;
+                    }
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r4 = r3 << 5;
+                    r2 = r3 << 3;
+                    r2 = r4 - r2;
+                    r3 = r3 + 1;
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r2 = r4 + r2;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    r4 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    r2 = r3 << 2;
+                    r2 = r2 + -4;
+                    r2 = r4 + r2;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r4 == r23) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13504;
+                        run_13400(); return;
+                    }
+                case 0x12880:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x12890;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x12890:
+                    r2 = r0 + 4;
+                    r3 = r0 + 5;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12768;
+                        run_12600(); return;
+                    }
+                case 0x128a4:
+                    r5 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x128c4;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -8912;
+                    /* Next insn is delay slot */ 
+                    r31=0x128c4;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x128c4:
+                    r5 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x128e4;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -8888;
+                    /* Next insn is delay slot */ 
+                    r31=0x128e4;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x128e4:
+                    r5 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r6 = r0 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x128f8;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x128f8:
+                    r3 = readPages[(r28+-30808)>>>12][((r28+-30808)>>>2)&0x3ff];
+                    r2 = readPages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff];
+                    r2 = r3 | r2;
+                    r4 = r2 & 4;
+                    r3 = r2 + r0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12ad4;
+                        run_12a00(); return;
+                    }
+                    r4 = r2 & 2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x131f4;
+                        run_13000(); return;
+                    }
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r2;
+                case 0x12928:
+                    r4 = r2 & 64;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12940;
+                        continue;
+                    }
+                    r3 = r0 + -17;
+                    r3 = r2 & r3;
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r3;
+                case 0x12940:
+                    r2 = r3 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x131b4;
+                        run_13000(); return;
+                    }
+                    r2 = r3 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13250;
+                        run_13200(); return;
+                    }
+                    r2 = r3 & 32;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12768;
+                        run_12600(); return;
+                    }
+                    f0 = readPages[(r21+12)>>>12][((r21+12)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-32372)>>>12][((r28+-32372)>>>2)&0x3ff];
+                    f1 = readPages[(r21+8)>>>12][((r21+8)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-32376)>>>12][((r28+-32376)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<=(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12768;
+                        run_12600(); return;
+                    }
+                    f2 = readPages[(r28+-32364)>>>12][((r28+-32364)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-32368)>>>12][((r28+-32368)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<=(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12768;
+                        run_12600(); return;
+                    }
+                    r3 = r3 | 8;
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x12768;
+                    run_12600(); return;
+                case 0x129b8:
+                    /* Next insn is delay slot */ 
+                    r31=0x129c0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x129c0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x126a8;
+                    run_12600(); return;
+                case 0x129cc:
+                    /* Next insn is delay slot */ 
+                    r31=0x129d4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x129d4:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r22 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x126e8;
+                    run_12600(); return;
+                case 0x129e0:
+                    r16 = r28 + -32652;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x129ec:
+                    r16 = r28 + -32636;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x129f8:
+                    r16 = r28 + -32492;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x12a00:
+                    pc=0x12a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_12a00() throws ExecutionException { /* 0x12a00 - 0x12c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x12a00:
+                case 0x12a04:
+                    r16 = r28 + -32452;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x12a10:
+                    r16 = r28 + -32612;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x12a1c:
+                    r16 = r28 + -32604;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x12a28:
+                    r16 = r28 + -32620;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x12a34:
+                    /* Next insn is delay slot */ 
+                    r31=0x12a3c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12a3c:
+                    r3 = r0 + 61;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x134d0;
+                        run_13400(); return;
+                    }
+                    r3 = r0 + 62;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x131a8;
+                        run_13000(); return;
+                    }
+                    r3 = r0 + 60;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x134c4;
+                        run_13400(); return;
+                    }
+                    r16 = r28 + -32524;
+                    /* Next insn is delay slot */ 
+                    pc=0x127d4;
+                    run_12600(); return;
+                case 0x12a6c:
+                    /* Next insn is delay slot */ 
+                    r31=0x12a74;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12a74:
+                    r3 = r0 + 61;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14378;
+                        run_14200(); return;
+                    }
+                    r16 = r28 + -32500;
+                    /* Next insn is delay slot */ 
+                    pc=0x127d4;
+                    run_12600(); return;
+                case 0x12a8c:
+                    r16 = r28 + -32468;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x12a98:
+                    /* Next insn is delay slot */ 
+                    r31=0x12aa0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12aa0:
+                    r16 = r2 + r0;
+                    r2 = r0 + 61;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x134f8;
+                        run_13400(); return;
+                    }
+                    r2 = r0 + 62;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x134dc;
+                        run_13400(); return;
+                    }
+                    r2 = r0 + 60;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x131a8;
+                        run_13000(); return;
+                    }
+                    r16 = r28 + -32540;
+                    /* Next insn is delay slot */ 
+                    pc=0x127d4;
+                    run_12600(); return;
+                case 0x12ad4:
+                    r3 = r0 + -4;
+                    r2 = r2 & r3;
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r2;
+                    r3 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12928;
+                    run_12800(); return;
+                case 0x12aec:
+                    r16 = r28 + -32548;
+                case 0x12af0:
+                    /* Next insn is delay slot */ 
+                    r31=0x12af8;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12af8:
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r2 = r22 + 1;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r22 = r22 << 2;
+                    r22 = r2 + r22;
+                    writePages[(r22+0)>>>12][((r22+0)>>>2)&0x3ff] = r16;
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x125d8;
+                    run_12400(); return;
+                case 0x12b24:
+                    r16 = r28 + -32556;
+                    /* Next insn is delay slot */ 
+                    pc=0x12af0;
+                    continue;
+                case 0x12b30:
+                    r16 = r28 + -32564;
+                    /* Next insn is delay slot */ 
+                    pc=0x12af0;
+                    continue;
+                case 0x12b3c:
+                    /* Next insn is delay slot */ 
+                    r31=0x12b44;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12b44:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r3 = r2 + -48;
+                    r3 = (r3&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1320c;
+                        run_13200(); return;
+                    }
+                    f26 = readPages[(r28+-32396)>>>12][((r28+-32396)>>>2)&0x3ff];
+                    f28 = r0;
+                    f24 = readPages[(r28+-32388)>>>12][((r28+-32388)>>>2)&0x3ff];
+                    f27 = readPages[(r28+-32400)>>>12][((r28+-32400)>>>2)&0x3ff];
+                    f29 = r0;
+                    f25 = readPages[(r28+-32392)>>>12][((r28+-32392)>>>2)&0x3ff];
+                case 0x12b78:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f29&0xffffffffL) << 32) | (f28&0xffffffffL)))*(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f29 = (int)(l >>> 32); f28 = (int)l; }
+                    r2 = r2 & 15;
+                    f2 = r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))*(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f27 = (int)(l >>> 32); f26 = (int)l; }
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f29&0xffffffffL) << 32) | (f28&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f29 = (int)(l >>> 32); f28 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    r31=0x12b98;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12b98:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r3 = r2 + -48;
+                    r3 = (r3&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12b78;
+                        continue;
+                    }
+                case 0x12bb0:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f29&0xffffffffL) << 32) | (f28&0xffffffffL)))/(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))); f27 = (int)(l >>> 32); f26 = (int)l; }
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r4 = r3 << 5;
+                    r2 = r3 << 3;
+                    r2 = r4 - r2;
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r2 = r4 + r2;
+                    r4 = r0 + 336;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r4;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = f26;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = f27;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r3;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x12bf4:
+                    /* Next insn is delay slot */ 
+                    r31=0x12bfc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12bfc:
+                    r4 = r29 + 16;
+                case 0x12c00:
+                    pc=0x12c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_12c00() throws ExecutionException { /* 0x12c00 - 0x12e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x12c00:
+                    /* Next insn is delay slot */ 
+                    r31=0x12c08;
+                    pc=0x28000;
+                    run_28000(); return;
+                case 0x12c08:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = r2 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13260;
+                        run_13200(); return;
+                    }
+                    r4 = r2 + r0;
+                case 0x12c20:
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r4 = r4 | 64;
+                    r5 = r3 << 5;
+                    r2 = r3 << 3;
+                    r2 = r5 - r2;
+                    r5 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r2 = r5 + r2;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r4;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r3;
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r4;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                case 0x12c58:
+                    r2 = r0 + 1;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r2;
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x124a4;
+                    run_12400(); return;
+                case 0x12c6c:
+                    r16 = r28 + -32660;
+                    /* Next insn is delay slot */ 
+                    pc=0x12af0;
+                    run_12a00(); return;
+                case 0x12c78:
+                    /* Next insn is delay slot */ 
+                    r31=0x12c80;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12c80:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r3 = r2 + -48;
+                    r3 = (r3&0xffffffffL) < (8&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x144a4;
+                        run_14400(); return;
+                    }
+                    r22 = r0 + r0;
+                    r16 = r0 + r0;
+                case 0x12ca0:
+                    r2 = r2 & 7;
+                    r16 = r16 << 3;
+                    r16 = r16 + r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x12cb4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12cb4:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r22 = r22 + 1;
+                    r3 = r2 + -48;
+                    r3 = (r3&0xffffffffL) < (8&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12ca0;
+                        continue;
+                    }
+                    r2 = r22 < 4 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1319c;
+                        run_13000(); return;
+                    }
+                    r22 = r22 < 7 ? 1 : 0;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12e18;
+                        run_12e00(); return;
+                    }
+                case 0x12ce4:
+                    r2 = r16 < 256 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1319c;
+                        run_13000(); return;
+                    }
+                    r5 = r0 + 82;
+                    /* Next insn is delay slot */ 
+                    pc=0x12e2c;
+                    run_12e00(); return;
+                case 0x12cfc:
+                    r16 = r28 + -32460;
+                    /* Next insn is delay slot */ 
+                    pc=0x12af0;
+                    run_12a00(); return;
+                case 0x12d08:
+                    r22 = r0 + r0;
+                    r16 = r0 + -1;
+                case 0x12d10:
+                    /* Next insn is delay slot */ 
+                    r31=0x12d18;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12d18:
+                    r2 = r2 & 255;
+                    r3 = r19 + r2;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r16 = r16 + 1;
+                    r3 = r3 & 32;
+                    r2 = r2 | r3;
+                    r3 = r2 + -48;
+                    r4 = r2 << 24;
+                    r3 = (r3&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    r4 = r4 >> 24;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13138;
+                        run_13000(); return;
+                    }
+                    r2 = r2 + -97;
+                    r2 = (r2&0xffffffffL) < (6&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13154;
+                        run_13000(); return;
+                    }
+                    r2 = r16 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12d80;
+                        continue;
+                    }
+                    r16 = r16 < 5 ? 1 : 0;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13320;
+                        run_13200(); return;
+                    }
+                    r2 = 1 << 16;
+                    r2 = r22 < r2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14264;
+                        run_14200(); return;
+                    }
+                case 0x12d80:
+                    r5 = r0 + 80;
+                case 0x12d84:
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r4 = r3 << 5;
+                    r2 = r3 << 3;
+                    r2 = r4 - r2;
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r2 = r4 + r2;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r3;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r5;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r22;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    continue;
+                case 0x12dbc:
+                    r30 = r0 + -1;
+                    r16 = r0 + r0;
+                    r22 = r0 + 46;
+                case 0x12dc8:
+                    r30 = r30 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x12dd4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12dd4:
+                    if(r2 == r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13190;
+                        run_13000(); return;
+                    }
+                case 0x12ddc:
+                    r4 = r2 < 47 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13168;
+                        run_13000(); return;
+                    }
+                    r4 = r0 + 48;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13190;
+                        run_13000(); return;
+                    }
+                    r5 = r0 + 49;
+                    if(r2 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13174;
+                        run_13000(); return;
+                    }
+                case 0x12e00:
+                    pc=0x12e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_12e00() throws ExecutionException { /* 0x12e00 - 0x13000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x12e00:
+                    r2 = r30 < 9 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1319c;
+                        run_13000(); return;
+                    }
+                    r3 = r30 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12ce4;
+                        run_12c00(); return;
+                    }
+                case 0x12e18:
+                    r2 = 1 << 16;
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1319c;
+                        run_13000(); return;
+                    }
+                    r5 = r0 + 84;
+                case 0x12e2c:
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r4 = r3 << 5;
+                    r2 = r3 << 3;
+                    r2 = r4 - r2;
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r2 = r4 + r2;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r5;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r16;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r3;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x12e64:
+                    /* Next insn is delay slot */ 
+                    r31=0x12e6c;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x12e6c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12c58;
+                        run_12c00(); return;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x143f8;
+                        run_14200(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x12e8c;
+                    pc=0x18c00;
+                    run_18c00(); return;
+                case 0x12e8c:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x12e98;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x12e98:
+                    if(r2 == r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1471c;
+                        run_14600(); return;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x143d8;
+                        run_14200(); return;
+                    }
+                case 0x12eb0:
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r4 = r3 << 5;
+                    r2 = r3 << 3;
+                    r2 = r4 - r2;
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r4 + r2;
+                    r4 = r0 + 88;
+                case 0x12ed4:
+                    r3 = r3 + 1;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r4;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r16;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r3;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x12ef0:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r22 = r0 + 43;
+                    r16 = r0 + 43;
+                    /* Next insn is delay slot */ 
+                    pc=0x12f3c;
+                    continue;
+                case 0x12f0c:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r22&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x12f28;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12f28:
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12f84;
+                        continue;
+                    }
+                case 0x12f30:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                case 0x12f3c:
+                    r3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12f0c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x12f54;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x12f54:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r22&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x12f7c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12f7c:
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12f30;
+                        continue;
+                    }
+                case 0x12f84:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r16 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x12f98;
+                    pc=0x30800;
+                    run_30800(); return;
+                case 0x12f98:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x12fb0;
+                    pc=0x12200;
+                    run_12200(); return;
+                case 0x12fb0:
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x12fb8:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r16 = r0 + r0;
+                    r30 = r0 + 45;
+                    r22 = r0 + 45;
+                    /* Next insn is delay slot */ 
+                    pc=0x1300c;
+                    run_13000(); return;
+                case 0x12fd8:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r30&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r16 = r16 ^ 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x12ff8;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x12ff8:
+                    if(r2 != r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1257c;
+                        run_12400(); return;
+                    }
+                case 0x13000:
+                    pc=0x13000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_13000() throws ExecutionException { /* 0x13000 - 0x13200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x13000:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                case 0x1300c:
+                    r3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12fd8;
+                        run_12e00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x13024;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x13024:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x12fd8;
+                    run_12e00(); return;
+                case 0x13038:
+                    r3 = r3 & 255;
+                    r3 = r19 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14394;
+                        run_14200(); return;
+                    }
+                    r16 = r28 + -30776;
+                    /* Next insn is delay slot */ 
+                    pc=0x127d4;
+                    run_12600(); return;
+                case 0x1305c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8976;
+                    /* Next insn is delay slot */ 
+                    r31=0x1306c;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x1306c:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1427c;
+                        run_14200(); return;
+                    }
+                case 0x130ac:
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r2 = r8 ^ r2;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r8 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r2 = r8 + r2;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r2;
+                case 0x130d4:
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 << 2;
+                    r2 = r2 + -8;
+                    r16 = r16 + r2;
+                    r30 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                case 0x130f0:
+                    r5 = r5 & 103;
+                    r5 = r5 | r7;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r5;
+                    r7 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r0 + -17;
+                    r4 = r7 | r4;
+                    r5 = r5 & r4;
+                    r4 = r0 + -9;
+                    r5 = r5 & r4;
+                    r6 = r6 + -1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r5;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r6;
+                case 0x13120:
+                    writePages[(r28+-30808)>>>12][((r28+-30808)>>>2)&0x3ff] = r0;
+                case 0x13124:
+                    r22 = r22 + -1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r30;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r22;
+                    /* Next insn is delay slot */ 
+                    pc=0x125d8;
+                    run_12400(); return;
+                case 0x13138:
+                    r2 = r2 + -97;
+                    r22 = r22 << 4;
+                    r3 = r4 + -48;
+                    r2 = (r2&0xffffffffL) < (6&0xffffffffL) ? 1 : 0;
+                    r22 = r22 + r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12d10;
+                        run_12c00(); return;
+                    }
+                case 0x13154:
+                    r22 = r22 << 4;
+                    r22 = r4 + r22;
+                    r22 = r22 + -87;
+                    /* Next insn is delay slot */ 
+                    pc=0x12d10;
+                    run_12c00(); return;
+                case 0x13168:
+                    r3 = r0 + 35;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12e00;
+                        run_12e00(); return;
+                    }
+                case 0x13174:
+                    r16 = r16 << 1;
+                    r16 = r16 | 1;
+                    r30 = r30 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x13188;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x13188:
+                    if(r2 != r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12ddc;
+                        run_12c00(); return;
+                    }
+                case 0x13190:
+                    r16 = r16 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x12dc8;
+                    run_12c00(); return;
+                case 0x1319c:
+                    r5 = r0 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=0x12e2c;
+                    run_12e00(); return;
+                case 0x131a8:
+                    r16 = r28 + -32508;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x131b4:
+                    r2 = r3 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13244;
+                        run_13200(); return;
+                    }
+                    r2 = r3 & 32;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12768;
+                        run_12600(); return;
+                    }
+                    r2 = readPages[(r21+8)>>>12][((r21+8)>>>2)&0x3ff];
+                    r2 = r2 + 128;
+                    r2 = (r2&0xffffffffL) < (384&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12768;
+                        run_12600(); return;
+                    }
+                    r3 = r3 | 8;
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x12768;
+                    run_12600(); return;
+                case 0x131f4:
+                    r3 = r0 + -2;
+                    r2 = r2 & r3;
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r2;
+                case 0x13200:
+                    pc=0x13200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_13200() throws ExecutionException { /* 0x13200 - 0x13400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x13200:
+                    r3 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12928;
+                    run_12800(); return;
+                case 0x1320c:
+                    /* Next insn is delay slot */ 
+                    r31=0x13214;
+                    pc=0x1ec00;
+                    run_1ec00(); return;
+                case 0x13214:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12890;
+                        run_12800(); return;
+                    }
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + 1;
+                    r6 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r6 = r6 + -1;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1323c;
+                    pc=0x12200;
+                    run_12200(); return;
+                case 0x1323c:
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x13244:
+                    writePages[(r21+8)>>>12][((r21+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12768;
+                    run_12600(); return;
+                case 0x13250:
+                    writePages[(r21+12)>>>12][((r21+12)>>>2)&0x3ff] = r0;
+                    writePages[(r21+8)>>>12][((r21+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12768;
+                    run_12600(); return;
+                case 0x13260:
+                    r4 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r5 = r5 + -9164;
+                    /* Next insn is delay slot */ 
+                    r31=0x13278;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x13278:
+                    r4 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1443c;
+                        run_14400(); return;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                case 0x13298:
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x132a4;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x132a4:
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x12c20;
+                    run_12c00(); return;
+                case 0x132b0:
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r3 = r0 + 110;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r4 = r4 | 32;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14474;
+                        run_14400(); return;
+                    }
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r0 + 111;
+                    r4 = r4 | 32;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14474;
+                        run_14400(); return;
+                    }
+                    addr=r2+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 116;
+                    r3 = r3 | 32;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14474;
+                        run_14400(); return;
+                    }
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = r28 + -32660;
+                    r2 = r22 + 1;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r22 = r22 << 2;
+                    r2 = r2 + r22;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                case 0x13314:
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x125d8;
+                    run_12400(); return;
+                case 0x13320:
+                    r2 = r22 < 256 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x12d80;
+                        run_12c00(); return;
+                    }
+                    r5 = r0 + 82;
+                    /* Next insn is delay slot */ 
+                    pc=0x12d84;
+                    run_12c00(); return;
+                case 0x13338:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x13348;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x13348:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    r6 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r6 = r6 + -1;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x13368;
+                    pc=0x12200;
+                    run_12200(); return;
+                case 0x13368:
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x13370:
+                    r16 = r22 & 15;
+                    /* Next insn is delay slot */ 
+                    r31=0x1337c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1337c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13478;
+                        run_13400(); return;
+                    }
+                    r2 = r0 + 98;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15480;
+                        run_15400(); return;
+                    }
+                    r2 = r0 + 120;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13478;
+                        run_13400(); return;
+                    }
+                    r16 = r0 + r0;
+                    r22 = r0 + -1;
+                case 0x133a8:
+                    /* Next insn is delay slot */ 
+                    r31=0x133b0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x133b0:
+                    r2 = r2 & 255;
+                    r3 = r19 + r2;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r22 = r22 + 1;
+                    r3 = r3 & 32;
+                    r2 = r2 | r3;
+                    r4 = r2 + -48;
+                    r3 = r2 << 24;
+                    r4 = (r4&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    r3 = r3 >> 24;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x146ec;
+                        run_14600(); return;
+                    }
+                    r2 = r2 + -97;
+                    r2 = (r2&0xffffffffL) < (6&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14708;
+                        run_14600(); return;
+                    }
+                    r2 = r22 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15474;
+                        run_15400(); return;
+                    }
+                    r22 = r22 < 5 ? 1 : 0;
+                case 0x13400:
+                    pc=0x13400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_13400() throws ExecutionException { /* 0x13400 - 0x13600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x13400:
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15590;
+                        run_15400(); return;
+                    }
+                    r2 = 1 << 16;
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15474;
+                        run_15400(); return;
+                    }
+                    r2 = r0 + 84;
+                case 0x1341c:
+                    r4 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r5 = r4 << 5;
+                    r3 = r4 << 3;
+                    r3 = r5 - r3;
+                    r5 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    r3 = r5 + r3;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r16;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r4;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x13454:
+                    r3 = r16 << 1;
+                    r16 = r16 << 3;
+                    r16 = r3 + r16;
+                    r2 = r2 & 15;
+                    r16 = r16 + r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x13470;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x13470:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                case 0x13478:
+                    r2 = r3 & 255;
+                    r4 = r2 + -48;
+                    r4 = (r4&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13454;
+                        continue;
+                    }
+                    r2 = r0 + 46;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15278;
+                        run_15200(); return;
+                    }
+                    r3 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r4 = r3 << 5;
+                    r2 = r3 << 3;
+                    r2 = r4 - r2;
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r4 + r2;
+                    r4 = r0 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=0x12ed4;
+                    run_12e00(); return;
+                case 0x134c4:
+                    r16 = r28 + -32572;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x134d0:
+                    r16 = r28 + -32516;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x134dc:
+                    /* Next insn is delay slot */ 
+                    r31=0x134e4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x134e4:
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14270;
+                        run_14200(); return;
+                    }
+                    r16 = r28 + -32580;
+                    /* Next insn is delay slot */ 
+                    pc=0x127d4;
+                    run_12600(); return;
+                case 0x134f8:
+                    r16 = r28 + -32532;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x13504:
+                    r22 = r3 + 1;
+                    r3 = r28 + -30776;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 2;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r22;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x124a4;
+                    run_12400(); return;
+                case 0x13524:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15124;
+                        run_15000(); return;
+                    }
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r2 = r8 < r2 ? 1 : 0;
+                    r2 = r2 ^ 1;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13588:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14bd0;
+                        run_14a00(); return;
+                    }
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r2 = r8 < r2 ? 1 : 0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x135e8:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                case 0x13600:
+                    pc=0x13600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_13600() throws ExecutionException { /* 0x13600 - 0x13800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x13600:
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14c4c;
+                        run_14c00(); return;
+                    }
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r2 = r2 < r8 ? 1 : 0;
+                    r2 = r2 ^ 1;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x1364c:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14890;
+                        run_14800(); return;
+                    }
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r2 = r8 ^ r2;
+                    r2 = (r2&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                case 0x136a4:
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x136b4:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1503c;
+                        run_15000(); return;
+                    }
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r2 = r8 - r2;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                case 0x13708:
+                    r8 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r2 = r8 - r2;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13728:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14a60;
+                        run_14a00(); return;
+                    }
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r2 = r8 + r2;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                case 0x1377c:
+                    r8 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r2 = r8 + r2;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x1379c:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 3;
+                    r5 = r6 << 5;
+                    r5 = r5 - r4;
+                    r4 = r5 + -24;
+                    r4 = r3 + r4;
+                    r7 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r8 = r7 & 256;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x144b4;
+                        run_14400(); return;
+                    }
+                    r8 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                case 0x137d0:
+                    r5 = r5 + -48;
+                    r3 = r3 + r5;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = r7 & 256;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x147a4;
+                        run_14600(); return;
+                    }
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r8 = r2 << (r8&0x1f);
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r8;
+                case 0x137fc:
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                case 0x13800:
+                    pc=0x13800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_13800() throws ExecutionException { /* 0x13800 - 0x13a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x13800:
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13810:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14f40;
+                        run_14e00(); return;
+                    }
+                    r2 = r0 + 2;
+                case 0x13854:
+                    r8 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r9 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r8 = r9 >>> (r8&0x1f);
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13870:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r4 = r2 + r4;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = r5 & 256;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14520;
+                        run_14400(); return;
+                    }
+                    r8 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                case 0x138a4:
+                    r3 = r3 + -48;
+                    r3 = r2 + r3;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14500;
+                        run_14400(); return;
+                    }
+                    r2 = r0 + 1;
+                    r8 = r2 << (r8&0x1f);
+                    f0 = r8;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    { long l = Double.doubleToLongBits(((double)f0)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f0 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    f1 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x138f8:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x150b0;
+                        run_15000(); return;
+                    }
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    { long hilo = (long)(r8) * ((long)r2); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r2 = lo;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x1395c:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 3;
+                    r7 = r6 << 5;
+                    r7 = r7 - r4;
+                    r4 = r7 + -24;
+                    r7 = r7 + -48;
+                    r4 = r3 + r4;
+                    r3 = r3 + r7;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r8 = r7 | r5;
+                    r8 = r8 & 256;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14cc8;
+                        run_14c00(); return;
+                    }
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15204;
+                        run_15200(); return;
+                    }
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r9 = r0 + 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x139e8;
+                        continue;
+                    }
+                case 0x139bc:
+                    r10 = r2 & 1;
+                    { long hilo = (long)(r9) * ((long)r8); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    if(r10 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x139d0;
+                        continue;
+                    }
+                    r9 = lo;
+                case 0x139d0:
+                    r2 = r2 >> 1;
+                    { long hilo = (long)(r8) * ((long)r8); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r8 = lo;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x139bc;
+                        continue;
+                    }
+                case 0x139e8:
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r9;
+                    r2 = r0 + 2;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x139fc:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                case 0x13a00:
+                    pc=0x13a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_13a00() throws ExecutionException { /* 0x13a00 - 0x13c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x13a00:
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r2 << 3;
+                    r6 = r2 << 5;
+                    r6 = r6 - r4;
+                    r4 = r6 + -24;
+                    r6 = r6 + -48;
+                    r4 = r3 + r4;
+                    r3 = r3 + r6;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r6 = r7 | r5;
+                    r6 = r6 & 256;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14e6c;
+                        run_14e00(); return;
+                    }
+                case 0x13a3c:
+                    r6 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14418;
+                        run_14400(); return;
+                    }
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        hi = r8%r6; lo = r8/r6;
+                        pc=0x13a60;
+                        continue;
+                    }
+                    hi = r8%r6; lo = r8/r6;
+                    throw new ExecutionException("Break");
+                case 0x13a60:
+                    r6 = lo;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r6;
+                    r6 = r2 + r0;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13a78:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r2 << 3;
+                    r6 = r2 << 5;
+                    r6 = r6 - r4;
+                    r4 = r6 + -24;
+                    r6 = r6 + -48;
+                    r4 = r3 + r4;
+                    r3 = r3 + r6;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r6 = r7 | r5;
+                    r6 = r6 & 256;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13a3c;
+                        continue;
+                    }
+                    r6 = r7 & 256;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13ae0;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x13ae0:
+                    r6 = r5 & 256;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x153a8;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                case 0x13b04:
+                    f2 = r0;
+                    f3 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))==(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x152ec;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r6 = r2 + r0;
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r2 = r0 + 2;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13b50:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r7 = r6 << 5;
+                    r7 = r7 - r3;
+                    r4 = r7 + -24;
+                    r3 = r7 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r8 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r9 = r8 | r5;
+                    r9 = r9 & 256;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14910;
+                        run_14800(); return;
+                    }
+                case 0x13b90:
+                    r8 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1456c;
+                        run_14400(); return;
+                    }
+                    r3 = r7 + -48;
+                    r3 = r2 + r3;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        hi = r2%r8; lo = r2/r8;
+                        pc=0x13bbc;
+                        continue;
+                    }
+                    hi = r2%r8; lo = r2/r8;
+                    throw new ExecutionException("Break");
+                case 0x13bbc:
+                    r7 = hi;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r7;
+                case 0x13bc4:
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x130d4;
+                    run_13000(); return;
+                case 0x13bd4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9064;
+                    /* Next insn is delay slot */ 
+                    r31=0x13be4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x13be4:
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 << 2;
+                    r2 = r2 + -8;
+                    r16 = r16 + r2;
+                    r30 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                case 0x13c00:
+                    pc=0x13c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_13c00() throws ExecutionException { /* 0x13c00 - 0x13e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x13c00:
+                    /* Next insn is delay slot */ 
+                    pc=0x13120;
+                    run_13000(); return;
+                case 0x13c08:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1458c;
+                        run_14400(); return;
+                    }
+                    r4 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r4 >> 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x140e4;
+                    run_14000(); return;
+                case 0x13c50:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14d70;
+                        run_14c00(); return;
+                    }
+                    r2 = r0 + 2;
+                case 0x13c94:
+                    r9 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r8 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r8 = r9 & r8;
+                case 0x13ca4:
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r8;
+                    r9 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r8 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r8 = r9 + r8;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13cc4:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14804;
+                        run_14800(); return;
+                    }
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r2 = r8 ^ r2;
+                    r2 = ((r0 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13d28:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14678;
+                        run_14600(); return;
+                    }
+                    r4 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r4 >> 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x140e4;
+                    run_14000(); return;
+                case 0x13d70:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x149e4;
+                        run_14800(); return;
+                    }
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r8 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r2 = r2 < r8 ? 1 : 0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x13dd0:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14740;
+                        run_14600(); return;
+                    }
+                case 0x13e00:
+                    pc=0x13e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_13e00() throws ExecutionException { /* 0x13e00 - 0x14000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x13e00:
+                    f0 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 | 256;
+                    { long l = Double.doubleToLongBits(((double)f0)); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                case 0x13e14:
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x13e20;
+                    pc=0x32e00;
+                    run_32e00(); return;
+                case 0x13e20:
+                    r2 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = f0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = f1;
+                case 0x13e30:
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x13120;
+                    run_13000(); return;
+                case 0x13e40:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1472c;
+                        run_14600(); return;
+                    }
+                    f2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 | 256;
+                    { long l = Double.doubleToLongBits(((double)f2)); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                case 0x13e84:
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x13e90;
+                    pc=0x32800;
+                    run_32800(); return;
+                case 0x13e90:
+                    /* Next insn is delay slot */ 
+                    pc=0x13e20;
+                    continue;
+                case 0x13e98:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x146c4;
+                        run_14600(); return;
+                    }
+                    f0 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 | 256;
+                    { long l = Double.doubleToLongBits(((double)f0)); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                case 0x13edc:
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x13ee8;
+                    pc=0x32c00;
+                    run_32c00(); return;
+                case 0x13ee8:
+                    /* Next insn is delay slot */ 
+                    pc=0x13e20;
+                    continue;
+                case 0x13ef0:
+                    r5 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r2 = r0 + 128;
+                    writePages[(r28+-30808)>>>12][((r28+-30808)>>>2)&0x3ff] = r2;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14770;
+                        run_14600(); return;
+                    }
+                    r2 = r0 + 17;
+                    if(r5 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14754;
+                        run_14600(); return;
+                    }
+                    r22 = r22 + -2;
+                    r2 = r0 + 1;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r22;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x124a4;
+                    run_12400(); return;
+                case 0x13f28:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13e30;
+                        continue;
+                    }
+                    f0 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r0 + -257;
+                    f1 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 & r4;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = f2;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x13120;
+                    run_13000(); return;
+                case 0x13fac:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r3 + r2;
+                    r3 = r0 + 1;
+                    writePages[(r2+-8)>>>12][((r2+-8)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x13120;
+                    run_13000(); return;
+                case 0x13fe0:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                case 0x14000:
+                    pc=0x14000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_14000() throws ExecutionException { /* 0x14000 - 0x14200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x14000:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1461c;
+                        run_14600(); return;
+                    }
+                    r5 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = 32768 << 16;
+                    r4 = r5 ^ r4;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r4;
+                case 0x14024:
+                    r4 = r0 + -9;
+                    r3 = r3 & r4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = r0 - r3;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x13120;
+                    run_13000(); return;
+                case 0x1404c:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x145d8;
+                        run_14400(); return;
+                    }
+                    r4 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                case 0x14088:
+                    r4 = ~(r0 | r4);
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r4;
+                    r4 = r0 + -9;
+                    r3 = r3 & r4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x13120;
+                    run_13000(); return;
+                case 0x140a8:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14634;
+                        run_14600(); return;
+                    }
+                    r4 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                case 0x140e4:
+                    r4 = r4 & 255;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r4;
+                    r3 = r3 | 8;
+                    r4 = r0 + -8;
+                    r3 = r3 & r4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x13120;
+                    run_13000(); return;
+                case 0x1410c:
+                    r4 = 3 << 16;
+                    r4 = r4 + 12288;
+                    /* Next insn is delay slot */ 
+                    r31=0x1411c;
+                    pc=0x12000;
+                    run_12000(); return;
+                case 0x1411c:
+                    /* Next insn is delay slot */ 
+                    pc=0x13be4;
+                    run_13a00(); return;
+                case 0x14124:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x13e30;
+                        run_13e00(); return;
+                    }
+                    f2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 | 256;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = f0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = f1;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x13120;
+                    run_13000(); return;
+                case 0x14180:
+                    r22 = r22 + -1;
+                    r2 = r0 + 5;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r22;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x1275c;
+                    run_12600(); return;
+                case 0x14198:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r4 = r6 << 5;
+                    r3 = r6 << 3;
+                    r3 = r4 - r3;
+                    r4 = r3 + -24;
+                    r3 = r3 + -48;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r7 | r5;
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14ad4;
+                        run_14a00(); return;
+                    }
+                    r2 = r0 + 2;
+                case 0x141dc:
+                    r9 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r8 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r8 = r9 | r8;
+                    /* Next insn is delay slot */ 
+                    pc=0x13ca4;
+                    run_13c00(); return;
+                case 0x141f4:
+                    r2 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r3 = r2 << 3;
+                case 0x14200:
+                    pc=0x14200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_14200() throws ExecutionException { /* 0x14200 - 0x14400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x14200:
+                    r2 = r2 << 5;
+                    r2 = r2 - r3;
+                    r3 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r2 = r2 + -24;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x146d8;
+                        run_14600(); return;
+                    }
+                    f2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 | 256;
+                    { long l = Double.doubleToLongBits(((double)f2)); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                case 0x14238:
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x14244;
+                    pc=0x32400;
+                    run_32400(); return;
+                case 0x14244:
+                    /* Next insn is delay slot */ 
+                    pc=0x13e20;
+                    run_13e00(); return;
+                case 0x1424c:
+                    r4 = 3 << 16;
+                    r4 = r4 + 12800;
+                    /* Next insn is delay slot */ 
+                    r31=0x1425c;
+                    pc=0x12000;
+                    run_12000(); return;
+                case 0x1425c:
+                    /* Next insn is delay slot */ 
+                    pc=0x13be4;
+                    run_13a00(); return;
+                case 0x14264:
+                    r5 = r0 + 84;
+                    /* Next insn is delay slot */ 
+                    pc=0x12d84;
+                    run_12c00(); return;
+                case 0x14270:
+                    r16 = r28 + -32588;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x1427c:
+                    r2 = r7 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x142cc;
+                        continue;
+                    }
+                    f0 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r8 = fcsr;
+                    r8 = fcsr;
+                    r1 = r8 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r8;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f2;
+                case 0x142cc:
+                    r2 = r5 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14318;
+                        continue;
+                    }
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 & r2;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                case 0x14318:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9024;
+                    /* Next insn is delay slot */ 
+                    r31=0x14328;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x14328:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r4 = r6 << 5;
+                    r4 = r4 - r3;
+                    r3 = r4 + -48;
+                    r4 = r4 + -24;
+                    r3 = r2 + r3;
+                    r4 = r2 + r4;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x130ac;
+                    run_13000(); return;
+                case 0x1435c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8936;
+                    /* Next insn is delay slot */ 
+                    r31=0x1436c;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1436c:
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x125d8;
+                    run_12400(); return;
+                case 0x14378:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9140;
+                    /* Next insn is delay slot */ 
+                    r31=0x14388;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x14388:
+                    r16 = r28 + -32500;
+                    /* Next insn is delay slot */ 
+                    pc=0x127cc;
+                    run_12600(); return;
+                case 0x14394:
+                    /* Next insn is delay slot */ 
+                    r31=0x1439c;
+                    pc=0x1f400;
+                    run_1f400(); return;
+                case 0x1439c:
+                    r4 = readPages[(r28+-30816)>>>12][((r28+-30816)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x143b0;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x143b0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14780;
+                        run_14600(); return;
+                    }
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x127d4;
+                    run_12600(); return;
+                case 0x143c4:
+                    /* Next insn is delay slot */ 
+                    r31=0x143cc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x143cc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1258c;
+                    run_12400(); return;
+                case 0x143d8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9200;
+                    /* Next insn is delay slot */ 
+                    r31=0x143e8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x143e8:
+                    /* Next insn is delay slot */ 
+                    r31=0x143f0;
+                    pc=0x1c800;
+                    run_1c800(); return;
+                case 0x143f0:
+                    /* Next insn is delay slot */ 
+                    pc=0x12eb0;
+                    run_12e00(); return;
+                case 0x143f8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6844;
+                case 0x14400:
+                    pc=0x14400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_14400() throws ExecutionException { /* 0x14400 - 0x14600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x14400:
+                    /* Next insn is delay slot */ 
+                    r31=0x14408;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x14408:
+                    /* Next insn is delay slot */ 
+                    r31=0x14410;
+                    pc=0x1c800;
+                    run_1c800(); return;
+                case 0x14410:
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x14418:
+                    r6 = r5 & 16;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x151a0;
+                        run_15000(); return;
+                    }
+                    r6 = r2 + r0;
+                case 0x14428:
+                    r2 = r0 + 2;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r0;
+                case 0x14430:
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x1443c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9228;
+                    r5 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    r31=0x14450;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x14450:
+                    r4 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x13298;
+                    run_13200(); return;
+                case 0x1445c:
+                    /* Next insn is delay slot */ 
+                    r31=0x14464;
+                    pc=0x1ec00;
+                    run_1ec00(); return;
+                case 0x14464:
+                    r3 = r0 + 3;
+                    r5 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x132b0;
+                        run_13200(); return;
+                    }
+                case 0x14474:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 40;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15420;
+                        run_15400(); return;
+                    }
+                    r6 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r5 = r0 + r0;
+                    r6 = r6 + -1;
+                    /* Next insn is delay slot */ 
+                    r31=0x1449c;
+                    pc=0x12200;
+                    run_12200(); return;
+                case 0x1449c:
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x144a4:
+                    r16 = r0 + r0;
+                    r5 = r0 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=0x12e2c;
+                    run_12e00(); return;
+                case 0x144b4:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r9 = r0 + -257;
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r7 = r7 & r9;
+                    r10 = fcsr;
+                    r10 = fcsr;
+                    r1 = r10 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r10;
+                    r8 = f2;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    pc=0x137d0;
+                    run_13600(); return;
+                case 0x14500:
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15318;
+                        run_15200(); return;
+                    }
+                    r2 = r2 >> (r8&0x1f);
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x136a4;
+                    run_13600(); return;
+                case 0x14520:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r7 = r0 + -257;
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 & r7;
+                    r10 = fcsr;
+                    r10 = fcsr;
+                    r1 = r10 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r10;
+                    r8 = f2;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x138a4;
+                    run_13800(); return;
+                case 0x1456c:
+                    r3 = r5 & 16;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15220;
+                        run_15200(); return;
+                    }
+                case 0x14578:
+                    r3 = r7 + -48;
+                    r3 = r2 + r3;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x13bc4;
+                    run_13a00(); return;
+                case 0x1458c:
+                    f0 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r0 + -257;
+                    f1 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 & r4;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    r4 = f2;
+                    r4 = r4 >> 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x140e4;
+                    run_14000(); return;
+                case 0x145d8:
+                    f0 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r0 + -257;
+                    f1 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 & r4;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                case 0x14600:
+                    pc=0x14600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_14600() throws ExecutionException { /* 0x14600 - 0x14800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x14600:
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    r4 = f2;
+                    /* Next insn is delay slot */ 
+                    pc=0x14088;
+                    run_14000(); return;
+                case 0x1461c:
+                    r4 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r0 - r4;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x14024;
+                    run_14000(); return;
+                case 0x14634:
+                    f0 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r0 + -257;
+                    f1 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 & r4;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    r4 = f2;
+                    /* Next insn is delay slot */ 
+                    pc=0x140e4;
+                    run_14000(); return;
+                case 0x14678:
+                    f0 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r0 + -257;
+                    f1 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r3 = r3 & r4;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    r4 = f2;
+                    r4 = r4 >> 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x140e4;
+                    run_14000(); return;
+                case 0x146c4:
+                    f12 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    f13 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x13edc;
+                    run_13e00(); return;
+                case 0x146d8:
+                    f12 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    f13 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14238;
+                    run_14200(); return;
+                case 0x146ec:
+                    r2 = r2 + -97;
+                    r16 = r16 << 4;
+                    r4 = r3 + -48;
+                    r2 = (r2&0xffffffffL) < (6&0xffffffffL) ? 1 : 0;
+                    r16 = r16 + r4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x133a8;
+                        run_13200(); return;
+                    }
+                case 0x14708:
+                    r16 = r16 << 4;
+                    r3 = r3 + r16;
+                    r16 = r3 + -87;
+                    /* Next insn is delay slot */ 
+                    pc=0x133a8;
+                    run_13200(); return;
+                case 0x1471c:
+                    /* Next insn is delay slot */ 
+                    r31=0x14724;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x14724:
+                    /* Next insn is delay slot */ 
+                    pc=0x12eb0;
+                    run_12e00(); return;
+                case 0x1472c:
+                    f12 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    f13 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x13e84;
+                    run_13e00(); return;
+                case 0x14740:
+                    f12 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    f13 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x13e14;
+                    run_13e00(); return;
+                case 0x14754:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9084;
+                    /* Next insn is delay slot */ 
+                    r31=0x14764;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x14764:
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x125d8;
+                    run_12400(); return;
+                case 0x14770:
+                    r20 = r20 + 1;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x13124;
+                    run_13000(); return;
+                case 0x14780:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9104;
+                    /* Next insn is delay slot */ 
+                    r31=0x14790;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x14790:
+                    r2 = r0 + 4;
+                    writePages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x1275c;
+                    run_12600(); return;
+                case 0x147a4:
+                    f12 = readPages[(r28+-32380)>>>12][((r28+-32380)>>>2)&0x3ff];
+                    f24 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    f0 = r8;
+                    f13 = readPages[(r28+-32384)>>>12][((r28+-32384)>>>2)&0x3ff];
+                    f25 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits(((double)f0)); f15 = (int)(l >>> 32); f14 = (int)l; }
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r3;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r4;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x147d4;
+                    pc=0x33400;
+                    run_33400(); return;
+                case 0x147d4:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                    r2 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r4 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r30 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r6 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x137fc;
+                    run_13600(); return;
+                case 0x14800:
+                    pc=0x14800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_14800() throws ExecutionException { /* 0x14800 - 0x14a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x14800:
+                case 0x14804:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1482c;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x1482c:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15330;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x14854:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r2 = r0 + 1;
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14904;
+                        continue;
+                    }
+                case 0x14878:
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x14890:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x148b8;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x148b8:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x153f8;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x148e0:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r2 = r0 + 1;
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14878;
+                        continue;
+                    }
+                case 0x14904:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x14878;
+                    continue;
+                case 0x14910:
+                    r2 = r8 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14960;
+                        continue;
+                    }
+                    f0 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r8 = r8 & r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r8;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f2;
+                case 0x14960:
+                    r2 = r5 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x149ac;
+                        continue;
+                    }
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 & r2;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                case 0x149ac:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9024;
+                    /* Next insn is delay slot */ 
+                    r31=0x149bc;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x149bc:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r7 = r6 << 5;
+                    r7 = r7 - r3;
+                    r4 = r7 + -24;
+                    r4 = r2 + r4;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x13b90;
+                    run_13a00(); return;
+                case 0x149e4:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14a0c;
+                        run_14a00(); return;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x14a00:
+                    pc=0x14a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_14a00() throws ExecutionException { /* 0x14a00 - 0x14c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x14a00:
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x14a0c:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x153bc;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x14a34:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r2 = r0 + 1;
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14878;
+                        run_14800(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x14904;
+                    run_14800(); return;
+                case 0x14a60:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14a88;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x14a88:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15344;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x14ab0:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1377c;
+                    run_13600(); return;
+                case 0x14ad4:
+                    r2 = r7 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14b24;
+                        continue;
+                    }
+                    f0 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r8 = fcsr;
+                    r8 = fcsr;
+                    r1 = r8 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r8;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f2;
+                case 0x14b24:
+                    r2 = r5 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14b70;
+                        continue;
+                    }
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 & r2;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                case 0x14b70:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9024;
+                    /* Next insn is delay slot */ 
+                    r31=0x14b80;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x14b80:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r4 = r6 << 5;
+                    r4 = r4 - r3;
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = r4 + -48;
+                    r4 = r4 + -24;
+                    r3 = r2 + r3;
+                    r4 = r2 + r4;
+                    r16 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 << 2;
+                    r2 = r2 + -8;
+                    r16 = r16 + r2;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r30 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x141dc;
+                    run_14000(); return;
+                case 0x14bd0:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14bf8;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x14bf8:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x153d0;
+                        run_15200(); return;
+                    }
+                case 0x14c00:
+                    pc=0x14c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_14c00() throws ExecutionException { /* 0x14c00 - 0x14e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x14c00:
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x14c20:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r2 = r0 + 1;
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14878;
+                        run_14800(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x14904;
+                    run_14800(); return;
+                case 0x14c4c:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14c74;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x14c74:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1536c;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x14c9c:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<=(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r2 = r0 + 1;
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14878;
+                        run_14800(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x14904;
+                    run_14800(); return;
+                case 0x14cc8:
+                    r8 = r7 & 256;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14cf0;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x14cf0:
+                    r7 = r5 & 256;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1540c;
+                        run_15400(); return;
+                    }
+                    f0 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    { long l = Double.doubleToLongBits(((double)f0)); f15 = (int)(l >>> 32); f14 = (int)l; }
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f14;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f15;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                case 0x14d14:
+                    f12 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    f13 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r3;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r4;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x14d38;
+                    pc=0x33400;
+                    run_33400(); return;
+                case 0x14d38:
+                    r3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                    r2 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r4 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r30 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x14d70:
+                    r2 = r7 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14dc0;
+                        continue;
+                    }
+                    f0 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r8 = fcsr;
+                    r8 = fcsr;
+                    r1 = r8 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r8;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f2;
+                case 0x14dc0:
+                    r2 = r5 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14e0c;
+                        run_14e00(); return;
+                    }
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 & r2;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                case 0x14e00:
+                    pc=0x14e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_14e00() throws ExecutionException { /* 0x14e00 - 0x15000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x14e00:
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                case 0x14e0c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9024;
+                    /* Next insn is delay slot */ 
+                    r31=0x14e1c;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x14e1c:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r4 = r6 << 5;
+                    r4 = r4 - r3;
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = r4 + -48;
+                    r4 = r4 + -24;
+                    r3 = r2 + r3;
+                    r4 = r2 + r4;
+                    r16 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 << 2;
+                    r2 = r2 + -8;
+                    r16 = r16 + r2;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r30 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x13c94;
+                    run_13c00(); return;
+                case 0x14e6c:
+                    r6 = r7 & 256;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14e94;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x14e94:
+                    r6 = r5 & 256;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15358;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                case 0x14eb8:
+                    f2 = r0;
+                    f3 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))==(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15258;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f2;
+                    r6 = r2 + r0;
+                    r2 = r0 + 2;
+                case 0x14f20:
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = r0 + -257;
+                    r7 = r7 & r5;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x14f40:
+                    r2 = r7 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14f90;
+                        continue;
+                    }
+                    f0 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r8 = fcsr;
+                    r8 = fcsr;
+                    r1 = r8 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r8;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f2;
+                case 0x14f90:
+                    r2 = r5 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14fdc;
+                        continue;
+                    }
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 & r2;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                case 0x14fdc:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9024;
+                    /* Next insn is delay slot */ 
+                    r31=0x14fec;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x14fec:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r4 = r6 << 5;
+                    r4 = r4 - r3;
+                case 0x15000:
+                    pc=0x15000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_15000() throws ExecutionException { /* 0x15000 - 0x15200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x15000:
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = r4 + -48;
+                    r4 = r4 + -24;
+                    r3 = r2 + r3;
+                    r4 = r2 + r4;
+                    r16 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 << 2;
+                    r2 = r2 + -8;
+                    r16 = r16 + r2;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r30 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x13854;
+                    run_13800(); return;
+                case 0x1503c:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15064;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x15064:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15380;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x1508c:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x13708;
+                    run_13600(); return;
+                case 0x150b0:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x150d8;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x150d8:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x153e4;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x15100:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x15124:
+                    r2 = r7 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1514c;
+                        continue;
+                    }
+                    f2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 | 256;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f1;
+                case 0x1514c:
+                    r2 = r5 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15394;
+                        run_15200(); return;
+                    }
+                    f2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r5 = r5 | 256;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = f0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = f1;
+                case 0x15174:
+                    f2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = r0 + -257;
+                    f3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r7 = r7 & r2;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<=(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r7;
+                    r2 = r0 + 1;
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14878;
+                        run_14800(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x14904;
+                    run_14800(); return;
+                case 0x151a0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8004;
+                case 0x151a8:
+                    /* Next insn is delay slot */ 
+                    r31=0x151b0;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x151b0:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r4 = r6 << 5;
+                    r4 = r4 - r3;
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = r4 + -48;
+                    r4 = r4 + -24;
+                    r3 = r2 + r3;
+                    r4 = r2 + r4;
+                    r16 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 << 2;
+                    r2 = r2 + -8;
+                    r16 = r16 + r2;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r30 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x14430;
+                    run_14400(); return;
+                case 0x15200:
+                    pc=0x15200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_15200() throws ExecutionException { /* 0x15200 - 0x15400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x15200:
+                case 0x15204:
+                    r2 = r5 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x14428;
+                        run_14400(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -9048;
+                    /* Next insn is delay slot */ 
+                    pc=0x151a8;
+                    run_15000(); return;
+                case 0x15220:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8004;
+                    /* Next insn is delay slot */ 
+                    r31=0x15230;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x15230:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r7 = r6 << 5;
+                    r7 = r7 - r3;
+                    r4 = r7 + -24;
+                    r4 = r2 + r4;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14578;
+                    run_14400(); return;
+                case 0x15258:
+                    r5 = r5 & 16;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15604;
+                        run_15600(); return;
+                    }
+                    r6 = r2 + r0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x14f20;
+                    run_14e00(); return;
+                case 0x15278:
+                    /* Next insn is delay slot */ 
+                    r31=0x15280;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x15280:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    f0 = r16;
+                    r3 = r2 + -48;
+                    r3 = (r3&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    { long l = Double.doubleToLongBits(((double)f0)); f29 = (int)(l >>> 32); f28 = (int)l; }
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15660;
+                        run_15600(); return;
+                    }
+                    f24 = readPages[(r28+-32388)>>>12][((r28+-32388)>>>2)&0x3ff];
+                    f26 = f22;
+                    f27 = f23;
+                    f25 = readPages[(r28+-32392)>>>12][((r28+-32392)>>>2)&0x3ff];
+                case 0x152ac:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f29&0xffffffffL) << 32) | (f28&0xffffffffL)))*(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f29 = (int)(l >>> 32); f28 = (int)l; }
+                    r2 = r2 & 15;
+                    f2 = r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))*(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f27 = (int)(l >>> 32); f26 = (int)l; }
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f29&0xffffffffL) << 32) | (f28&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f29 = (int)(l >>> 32); f28 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    r31=0x152cc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x152cc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r3 = r2 + -48;
+                    r3 = (r3&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x152ac;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x12bb0;
+                    run_12a00(); return;
+                case 0x152ec:
+                    r6 = r5 & 16;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x155a8;
+                        run_15400(); return;
+                    }
+                    r6 = r2 + r0;
+                    r2 = r0 + 2;
+                case 0x15300:
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r0;
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x130f0;
+                    run_13000(); return;
+                case 0x15318:
+                    r2 = ~(r0 | r2);
+                    r2 = r2 >> (r8&0x1f);
+                    r2 = ~(r0 | r2);
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x136a4;
+                    run_13600(); return;
+                case 0x15330:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14854;
+                    run_14800(); return;
+                case 0x15344:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14ab0;
+                    run_14a00(); return;
+                case 0x15358:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14eb8;
+                    run_14e00(); return;
+                case 0x1536c:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14c9c;
+                    run_14c00(); return;
+                case 0x15380:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1508c;
+                    run_15000(); return;
+                case 0x15394:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x15174;
+                    run_15000(); return;
+                case 0x153a8:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x13b04;
+                    run_13a00(); return;
+                case 0x153bc:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14a34;
+                    run_14a00(); return;
+                case 0x153d0:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14c20;
+                    run_14c00(); return;
+                case 0x153e4:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x15100;
+                    run_15000(); return;
+                case 0x153f8:
+                    f0 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                case 0x15400:
+                    pc=0x15400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_15400() throws ExecutionException { /* 0x15400 - 0x15600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x15400:
+                    f1 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x148e0;
+                    run_14800(); return;
+                case 0x1540c:
+                    f14 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f15 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x14d14;
+                    run_14c00(); return;
+                case 0x15420:
+                    r4 = readPages[(r28+-30784)>>>12][((r28+-30784)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1542c;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x1542c:
+                    r4 = readPages[(r28+-30820)>>>12][((r28+-30820)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30784)>>>12][((r28+-30784)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x15440;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x15440:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1555c;
+                        continue;
+                    }
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r22 + 1;
+                    writePages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r22 = r22 << 2;
+                    r2 = r2 + r22;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x125d8;
+                    run_12400(); return;
+                case 0x15474:
+                    r2 = r0 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=0x1341c;
+                    run_13400(); return;
+                case 0x15480:
+                    r30 = r0 + -1;
+                    r22 = r0 + r0;
+                    r16 = r0 + 46;
+                case 0x1548c:
+                    r30 = r30 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x15498;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x15498:
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15528;
+                        continue;
+                    }
+                    r5 = r2 < 47 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15534;
+                        continue;
+                    }
+                    r4 = r0 + 48;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15528;
+                        continue;
+                    }
+                    r5 = r0 + 49;
+                    if(r2 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15540;
+                        continue;
+                    }
+                case 0x154c4:
+                    r2 = r30 < 9 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15550;
+                        continue;
+                    }
+                    r4 = r30 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15578;
+                        continue;
+                    }
+                    r2 = 1 << 16;
+                    r2 = r22 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15550;
+                        continue;
+                    }
+                    r2 = r0 + 84;
+                case 0x154f0:
+                    r5 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r6 = r5 << 5;
+                    r4 = r5 << 3;
+                    r4 = r6 - r4;
+                    r6 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r5 = r5 + 1;
+                    r4 = r6 + r4;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = r22;
+                    writePages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff] = r5;
+                    writePages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x12c58;
+                    run_12c00(); return;
+                case 0x15528:
+                    r22 = r22 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1548c;
+                    continue;
+                case 0x15534:
+                    r3 = r0 + 35;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x154c4;
+                        continue;
+                    }
+                case 0x15540:
+                    r3 = r22 << 1;
+                    r22 = r3 | 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1548c;
+                    continue;
+                case 0x15550:
+                    r2 = r0 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=0x154f0;
+                    continue;
+                case 0x1555c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -9160;
+                    /* Next insn is delay slot */ 
+                    r31=0x1556c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1556c:
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x125d8;
+                    run_12400(); return;
+                case 0x15578:
+                    r2 = r22 < 256 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15550;
+                        continue;
+                    }
+                    r2 = r0 + 82;
+                    /* Next insn is delay slot */ 
+                    pc=0x154f0;
+                    continue;
+                case 0x15590:
+                    r2 = r16 < 256 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15474;
+                        continue;
+                    }
+                    r2 = r0 + 82;
+                    /* Next insn is delay slot */ 
+                    pc=0x1341c;
+                    run_13400(); return;
+                case 0x155a8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8004;
+                    /* Next insn is delay slot */ 
+                    r31=0x155b8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x155b8:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r4 = r6 << 5;
+                    r4 = r4 - r3;
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = r4 + -48;
+                    r4 = r4 + -24;
+                    r4 = r2 + r4;
+                    r3 = r2 + r3;
+                    r16 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 << 2;
+                    r2 = r2 + -8;
+                    r16 = r16 + r2;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r30 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x15300;
+                    run_15200(); return;
+                case 0x15600:
+                    pc=0x15600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_15600() throws ExecutionException { /* 0x15600 - 0x15800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x15600:
+                case 0x15604:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8004;
+                    /* Next insn is delay slot */ 
+                    r31=0x15614;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x15614:
+                    r6 = readPages[(r28+-30804)>>>12][((r28+-30804)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r6 << 3;
+                    r4 = r6 << 5;
+                    r4 = r4 - r3;
+                    r22 = readPages[(r28+-30796)>>>12][((r28+-30796)>>>2)&0x3ff];
+                    r3 = r4 + -48;
+                    r4 = r4 + -24;
+                    r3 = r2 + r3;
+                    r4 = r2 + r4;
+                    r16 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r22 << 2;
+                    r2 = r2 + -8;
+                    r16 = r16 + r2;
+                    r30 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30812)>>>12][((r28+-30812)>>>2)&0x3ff];
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x14f20;
+                    run_14e00(); return;
+                case 0x15660:
+                    f26 = f20;
+                    f27 = f21;
+                    /* Next insn is delay slot */ 
+                    pc=0x12bb0;
+                    run_12a00(); return;
+                case 0x15800:
+                    pc=0x15800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_15800() throws ExecutionException { /* 0x15800 - 0x15a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x15800:
+                    r29 = r29 + -24;
+                    r4 = r0 + 256;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x15814;
+                    pc=0x17600;
+                    run_17600(); return;
+                case 0x15814:
+                    r4 = r0 + 8;
+                    writePages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x15824;
+                    pc=0x17600;
+                    run_17600(); return;
+                case 0x15824:
+                    r4 = r0 + 256;
+                    writePages[(r28+-30784)>>>12][((r28+-30784)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x15834;
+                    pc=0x17600;
+                    run_17600(); return;
+                case 0x15834:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30816;
+                    r5 = r5 + 5648;
+                    writePages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x1584c;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x1584c:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30820;
+                    r5 = r5 + 5448;
+                    /* Next insn is delay slot */ 
+                    r31=0x15860;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x15860:
+                    r5 = readPages[(r28+-32736)>>>12][((r28+-32736)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff];
+                    r2 = r5 << 1;
+                    r5 = r5 << 3;
+                    writePages[(r28+-32736)>>>12][((r28+-32736)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x1587c;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x1587c:
+                    writePages[(r28+-30792)>>>12][((r28+-30792)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x158c8;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-32740)>>>12][((r28+-32740)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r2 << 1;
+                    r5 = r2 << 4;
+                    r2 = r2 << 6;
+                    r5 = r2 - r5;
+                    writePages[(r28+-32740)>>>12][((r28+-32740)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x158ac;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x158ac:
+                    writePages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15908;
+                        continue;
+                    }
+                case 0x158b8:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x158c8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    /* Next insn is delay slot */ 
+                    r31=0x158d8;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x158d8:
+                    r2 = readPages[(r28+-32740)>>>12][((r28+-32740)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff];
+                    r3 = r2 << 1;
+                    r5 = r2 << 4;
+                    r2 = r2 << 6;
+                    r5 = r2 - r5;
+                    writePages[(r28+-32740)>>>12][((r28+-32740)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x158fc;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x158fc:
+                    writePages[(r28+-30800)>>>12][((r28+-30800)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x158b8;
+                        continue;
+                    }
+                case 0x15908:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x15a00:
+                    pc=0x15a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_15a00() throws ExecutionException { /* 0x15a00 - 0x15c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x15a00:
+                    r29 = r29 + -48;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    r4 = r29 + 16;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x15a1c;
+                    pc=0x12400;
+                    run_12400(); return;
+                case 0x15a1c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15ad4;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = r0 + 64;
+                    r5 = r2 & 80;
+                    if(r5 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15af8;
+                        continue;
+                    }
+                case 0x15a38:
+                    r3 = r2 & 64;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15abc;
+                        continue;
+                    }
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15a70;
+                        continue;
+                    }
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x15a70:
+                    f0 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f1 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = f2;
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x15abc:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x15ad4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8036;
+                    /* Next insn is delay slot */ 
+                    r31=0x15ae4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x15ae4:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = r0 + 64;
+                    r5 = r2 & 80;
+                    if(r5 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15a38;
+                        continue;
+                    }
+                case 0x15af8:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r5 = r5 + -8864;
+                    /* Next insn is delay slot */ 
+                    r31=0x15b10;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15b10:
+                    r2 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x15b24;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15b24:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r5 = r5 + -6496;
+                    /* Next insn is delay slot */ 
+                    r31=0x15b38;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15b38:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x15b48;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x15b48:
+                    r2 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x15b5c;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x15b5c:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x15a38;
+                    continue;
+                case 0x15c00:
+                    pc=0x15c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_15c00() throws ExecutionException { /* 0x15c00 - 0x15e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x15c00:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x15c18;
+                    pc=0x12400;
+                    run_12400(); return;
+                case 0x15c18:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15d28;
+                        continue;
+                    }
+                case 0x15c20:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 & 256;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15c74;
+                        continue;
+                    }
+                    f0 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = r0 + -257;
+                    f1 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 & r3;
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = f2;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x15c74:
+                    r3 = r2 & 64;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15d40;
+                        continue;
+                    }
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15ca0;
+                        continue;
+                    }
+                case 0x15c8c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x15ca0:
+                    r2 = readPages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30824)>>>12][((r28+-30824)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff] = r2;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15c8c;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r5 = r5 + -8864;
+                    /* Next insn is delay slot */ 
+                    r31=0x15cd0;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15cd0:
+                    r2 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x15ce4;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15ce4:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r5 = r5 + -6496;
+                    /* Next insn is delay slot */ 
+                    r31=0x15cf8;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15cf8:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x15d08;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x15d08:
+                    r2 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r25 = r16 + r0;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x15d28:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8036;
+                    /* Next insn is delay slot */ 
+                    r31=0x15d38;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x15d38:
+                    /* Next insn is delay slot */ 
+                    pc=0x15c20;
+                    continue;
+                case 0x15d40:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -8020;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x15e00:
+                    pc=0x15e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_15e00() throws ExecutionException { /* 0x15e00 - 0x16000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x15e00:
+                    r29 = r29 + -48;
+                    r4 = r29 + 16;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x15e18;
+                    pc=0x12400;
+                    run_12400(); return;
+                case 0x15e18:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15ec8;
+                        continue;
+                    }
+                case 0x15e20:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = r2 & 64;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15eac;
+                        continue;
+                    }
+                    r3 = r2 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15ee0;
+                        continue;
+                    }
+                case 0x15e40:
+                    r2 = r2 & 256;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15e64;
+                        continue;
+                    }
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x15e64:
+                    f0 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f1 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    r2 = f2;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x15eac:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8020;
+                    /* Next insn is delay slot */ 
+                    r31=0x15ebc;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x15ebc:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x15e40;
+                    continue;
+                case 0x15ec8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8036;
+                    /* Next insn is delay slot */ 
+                    r31=0x15ed8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x15ed8:
+                    /* Next insn is delay slot */ 
+                    pc=0x15e20;
+                    continue;
+                case 0x15ee0:
+                    r3 = readPages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30824)>>>12][((r28+-30824)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff] = r3;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x15e40;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r5 = r5 + -8864;
+                    /* Next insn is delay slot */ 
+                    r31=0x15f10;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15f10:
+                    r2 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x15f24;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15f24:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r5 = r5 + -6496;
+                    /* Next insn is delay slot */ 
+                    r31=0x15f38;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x15f38:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x15f48;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x15f48:
+                    r2 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r16;
+                    r31=0x15f5c;
+                    return;
+                case 0x15f5c:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x15e40;
+                    continue;
+                case 0x16000:
+                    pc=0x16000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_16000() throws ExecutionException { /* 0x16000 - 0x16200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x16000:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x16018;
+                    pc=0x12400;
+                    run_12400(); return;
+                case 0x16018:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16094;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x160b8;
+                        continue;
+                    }
+                case 0x16034:
+                    r3 = r2 & 256;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16080;
+                        continue;
+                    }
+                    f0 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = r0 + -257;
+                    f1 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 & r3;
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = f2;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x16080:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16094:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8036;
+                    /* Next insn is delay slot */ 
+                    r31=0x160a4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x160a4:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 & 16;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16034;
+                        continue;
+                    }
+                case 0x160b8:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r5 = r5 + -8864;
+                    /* Next insn is delay slot */ 
+                    r31=0x160d0;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x160d0:
+                    r2 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x160e4;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x160e4:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r5 = r5 + -6496;
+                    /* Next insn is delay slot */ 
+                    r31=0x160f8;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x160f8:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x16108;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x16108:
+                    r2 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1611c;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x1611c:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x16034;
+                    continue;
+                case 0x16200:
+                    pc=0x16200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_16200() throws ExecutionException { /* 0x16200 - 0x16400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x16200:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x16218;
+                    pc=0x12400;
+                    run_12400(); return;
+                case 0x16218:
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r4 = r3 & 256;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1626c;
+                        continue;
+                    }
+                    f0 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r4 = r0 + -257;
+                    f1 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r3 = r3 & r4;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = f2;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                case 0x1626c:
+                    r3 = r2 < 2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1628c;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -8036;
+                    /* Next insn is delay slot */ 
+                    r31=0x16288;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x16288:
+                    r2 = r0 + r0;
+                case 0x1628c:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 64;
+                    r4 = r4 & 80;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x162b4;
+                        continue;
+                    }
+                case 0x162a0:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x162b4:
+                    r3 = readPages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30824)>>>12][((r28+-30824)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff] = r3;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x162a0;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r5 = r5 + -8864;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x162e8;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x162e8:
+                    r3 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x162fc;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x162fc:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r5 = r5 + -6496;
+                    /* Next insn is delay slot */ 
+                    r31=0x16310;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x16310:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x16320;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x16320:
+                    r3 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r16;
+                    r31=0x16334;
+                    return;
+                case 0x16334:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16400:
+                    pc=0x16400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_16400() throws ExecutionException { /* 0x16400 - 0x16600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x16400:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x16418;
+                    pc=0x12400;
+                    run_12400(); return;
+                case 0x16418:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x164dc;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 & 64;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16500;
+                        continue;
+                    }
+                case 0x16434:
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16454;
+                        continue;
+                    }
+                case 0x16440:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16454:
+                    r2 = readPages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30824)>>>12][((r28+-30824)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff] = r2;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16440;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r5 = r5 + -8864;
+                    /* Next insn is delay slot */ 
+                    r31=0x16484;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x16484:
+                    r2 = readPages[(r28+-30788)>>>12][((r28+-30788)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x16498;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x16498:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r5 = r5 + -6496;
+                    /* Next insn is delay slot */ 
+                    r31=0x164ac;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x164ac:
+                    r4 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x164bc;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x164bc:
+                    r2 = readPages[(r28+-30780)>>>12][((r28+-30780)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r25 = r16 + r0;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x164dc:
+                    r4 = 7 << 16;
+                    r4 = r4 + -8036;
+                    /* Next insn is delay slot */ 
+                    r31=0x164ec;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x164ec:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 & 64;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16434;
+                        continue;
+                    }
+                case 0x16500:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -8020;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x16600:
+                    pc=0x16600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_16600() throws ExecutionException { /* 0x16600 - 0x16800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x16600:
+                    r2 = readPages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16634;
+                        continue;
+                    }
+                    r2 = r2 + -1;
+                    writePages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff];
+                    r3 = r2 + 4;
+                    writePages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16634:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16800:
+                    pc=0x16800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_16800() throws ExecutionException { /* 0x16800 - 0x16a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x16800:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    r18 = r5 + r0;
+                    r16 = r0 + 45;
+                case 0x16820:
+                    r3 = readPages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x168ec;
+                        continue;
+                    }
+                    r6 = readPages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff];
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r7 = tmp;
+                    if(r7 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x168ec;
+                        continue;
+                    }
+                    r3 = r3 + -1;
+                    writePages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff] = r3;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r6 = r6 + 4;
+                    writePages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff] = r6;
+                    r4 = r2 + 1;
+                    if(r3 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x168ac;
+                        continue;
+                    }
+                    addr=r2+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x168ec;
+                        continue;
+                    }
+                    r4 = r2 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=r18;
+                    r31=0x1688c;
+                    return;
+                case 0x1688c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16820;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r5 = r5 + -7984;
+                    /* Next insn is delay slot */ 
+                    pc=0x168cc;
+                    continue;
+                case 0x168ac:
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x168b4;
+                    return;
+                case 0x168b4:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16820;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r5 = r5 + -7956;
+                case 0x168cc:
+                    r6 = 7 << 16;
+                    r6 = r6 + -7904;
+                    r7 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x168e0;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x168e0:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x168ec;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x168ec:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16a00:
+                    pc=0x16a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_16a00() throws ExecutionException { /* 0x16a00 - 0x16c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x16a00:
+                    r2 = readPages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    r7 = r4 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16a4c;
+                        continue;
+                    }
+                    r2 = r2 + -1;
+                    writePages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff];
+                    r3 = r2 + 4;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff] = r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16a4c;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16a4c:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    r5 = r5 + -7928;
+                    r6 = r6 + -7904;
+                    /* Next insn is delay slot */ 
+                    r31=0x16a6c;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x16a6c:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x16a78;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x16a78:
+                case 0x16c00:
+                    pc=0x16c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_16c00() throws ExecutionException { /* 0x16c00 - 0x16e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x16c00:
+                    writePages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff] = r4;
+                    writePages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff] = r5;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16c2c;
+                        continue;
+                    }
+                    r2 = r5 + 4;
+                    r4 = r4 + -1;
+                    writePages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff] = r2;
+                    writePages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff] = r4;
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16c2c:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16e00:
+                    pc=0x16e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_16e00() throws ExecutionException { /* 0x16e00 - 0x17000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x16e00:
+                    r2 = readPages[(r28+-30764)>>>12][((r28+-30764)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30768)>>>12][((r28+-30768)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    r7 = r6 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    writePages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff] = r3;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16e2c;
+                        continue;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x16e3c;
+                        continue;
+                    }
+                case 0x16e2c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x16e3c:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    r5 = r5 + -7912;
+                    r6 = r6 + -7904;
+                    /* Next insn is delay slot */ 
+                    r31=0x16e5c;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x16e5c:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x16e68;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x16e68:
+                case 0x17000:
+                    pc=0x17000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_17000() throws ExecutionException { /* 0x17000 - 0x17200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x17000:
+                    r4 = readPages[(r28+-30760)>>>12][((r28+-30760)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17054;
+                        continue;
+                    }
+                case 0x17014:
+                    r6 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x17024;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x17024:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17040;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17040:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17054:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30760;
+                    r5 = r5 + 5848;
+                    /* Next insn is delay slot */ 
+                    r31=0x17068;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x17068:
+                    r4 = readPages[(r28+-30760)>>>12][((r28+-30760)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x17014;
+                    continue;
+                case 0x17200:
+                    pc=0x17200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_17200() throws ExecutionException { /* 0x17200 - 0x17400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x17200:
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17228;
+                        continue;
+                    }
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17234;
+                        continue;
+                    }
+                case 0x17228:
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17234:
+                    r4 = 7 << 16;
+                    r4 = r4 + -7876;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x17400:
+                    pc=0x17400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_17400() throws ExecutionException { /* 0x17400 - 0x17600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x17400:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17418;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    writePages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17418:
+                    r4 = 7 << 16;
+                    r4 = r4 + 5996;
+                    r2 = 7 << 16;
+                    writePages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17600:
+                    pc=0x17600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_17600() throws ExecutionException { /* 0x17600 - 0x17800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x17600:
+                    r29 = r29 + -32;
+                    r2 = r4 < 128 ? 1 : 0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = r4 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17624;
+                        continue;
+                    }
+                    r17 = r0 + 128;
+                case 0x17624:
+                    r4 = r0 + 12;
+                    /* Next insn is delay slot */ 
+                    r31=0x17630;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x17630:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17678;
+                        continue;
+                    }
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r17;
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x17650;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x17650:
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17678;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17678:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r7 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r4 + -7800;
+                    r5 = r0 + 1;
+                    r6 = r0 + 37;
+                    /* Next insn is delay slot */ 
+                    r31=0x17698;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x17698:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x176a4;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x176a4:
+                case 0x17800:
+                    pc=0x17800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_17800() throws ExecutionException { /* 0x17800 - 0x17a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x17800:
+                    r29 = r29 + -40;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    r17 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    r17 = r17 << 1;
+                    r16 = r4 + r0;
+                    r4 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r17 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x1782c;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x1782c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17854;
+                        continue;
+                    }
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r17;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17854:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x17868;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x17868:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r17;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17a00:
+                    pc=0x17a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_17a00() throws ExecutionException { /* 0x17a00 - 0x17c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x17a00:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    r4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x17a1c;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x17a1c:
+                    r5 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r6 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x17a30;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x17a30:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17c00:
+                    pc=0x17c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_17c00() throws ExecutionException { /* 0x17c00 - 0x17e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x17c00:
+                    r29 = r29 + -40;
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    r17 = r5 << 24;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    r16 = r4 + r0;
+                    r17 = r17 >> 24;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17c60;
+                        continue;
+                    }
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r3 + 1;
+                    r3 = r2 + r3;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17c60:
+                    r18 = r3 << 1;
+                    r4 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x17c74;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x17c74:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17cb4;
+                        continue;
+                    }
+                case 0x17c7c:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r18;
+                    r4 = r3 + 1;
+                    r3 = r2 + r3;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17cb4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x17cc8;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x17cc8:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x17c7c;
+                    continue;
+                case 0x17e00:
+                    pc=0x17e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_17e00() throws ExecutionException { /* 0x17e00 - 0x18000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x17e00:
+                    r29 = r29 + -48;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r17 = tmp;
+                    r18 = r5 + 1;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17ec8;
+                        continue;
+                    }
+                    r19 = 7 << 16;
+                    r16 = r4 + r0;
+                    r19 = r19 + -6876;
+                    /* Next insn is delay slot */ 
+                    pc=0x17e68;
+                    continue;
+                case 0x17e40:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r5 + 1;
+                    r5 = r2 + r5;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r3;
+                    r18 = r18 + 1;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r18+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r17 = tmp;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17ec8;
+                        continue;
+                    }
+                case 0x17e68:
+                    r5 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    if(r5 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17e40;
+                        continue;
+                    }
+                    r20 = r5 << 1;
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r5 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x17e90;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x17e90:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17eec;
+                        continue;
+                    }
+                case 0x17e98:
+                    r5 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r20;
+                    r3 = r5 + 1;
+                    r5 = r2 + r5;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r3;
+                    r18 = r18 + 1;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r18+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r17 = tmp;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x17e68;
+                        continue;
+                    }
+                case 0x17ec8:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x17eec:
+                    r4 = r19 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x17efc;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x17efc:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x17e98;
+                    continue;
+                case 0x18000:
+                    pc=0x18000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_18000() throws ExecutionException { /* 0x18000 - 0x18200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x18000:
+                    r29 = r29 + -40;
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    r18 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    r2 = r2 < r18 ? 1 : 0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    r17 = r5 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1808c;
+                        continue;
+                    }
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                case 0x18034:
+                    r4 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1806c;
+                        continue;
+                    }
+                case 0x1804c:
+                    r3 = r3 | 32;
+                    r2 = r2 + 1;
+                    r4 = r4 + 1;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1804c;
+                        continue;
+                    }
+                case 0x1806c:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1808c:
+                    r4 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1809c;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x1809c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x180b4;
+                        continue;
+                    }
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r18;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x18034;
+                    continue;
+                case 0x180b4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x180c8;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x180c8:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r18;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x18034;
+                    continue;
+                case 0x18200:
+                    pc=0x18200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_18200() throws ExecutionException { /* 0x18200 - 0x18400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x18200:
+                    r29 = r29 + -24;
+                    r4 = r0 + 12;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x18218;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x18218:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x18260;
+                        continue;
+                    }
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    r4 = r0 + 1024;
+                    r2 = r0 + 1024;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x1823c;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x1823c:
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x18260;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18260:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r7 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r4 + -7800;
+                    r5 = r0 + 1;
+                    r6 = r0 + 37;
+                    /* Next insn is delay slot */ 
+                    r31=0x18280;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x18280:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x1828c;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x1828c:
+                case 0x18400:
+                    pc=0x18400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_18400() throws ExecutionException { /* 0x18400 - 0x18600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x18400:
+                    r2 = r4 << 24;
+                    r2 = r2 >> 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18600:
+                    pc=0x18600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_18600() throws ExecutionException { /* 0x18600 - 0x18800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x18600:
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    r3 = r4 & 255;
+                    r2 = r3 + -65;
+                    r2 = (r2&0xffffffffL) < (26&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1864c;
+                        continue;
+                    }
+                    r2 = r3 + -97;
+                    r2 = (r2&0xffffffffL) < (26&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x18640;
+                        continue;
+                    }
+                    r3 = r3 + -32;
+                    r2 = r3 << 24;
+                    r2 = r2 >> 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18640:
+                    r2 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1864c:
+                    r2 = r0 + -128;
+                    r2 = r4 | r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18800:
+                    pc=0x18800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_18800() throws ExecutionException { /* 0x18800 - 0x18a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x18800:
+                    r2 = readPages[(r28+-32344)>>>12][((r28+-32344)>>>2)&0x3ff];
+                    r4 = r4 & 255;
+                    r4 = r2 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18a00:
+                    pc=0x18a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_18a00() throws ExecutionException { /* 0x18a00 - 0x18c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x18a00:
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    r3 = r4 & 255;
+                    r2 = r3 + -97;
+                    r2 = (r2&0xffffffffL) < (26&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x18a64;
+                        continue;
+                    }
+                    r2 = r3 + -91;
+                    r2 = (r2&0xffffffffL) < (5&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x18a50;
+                        continue;
+                    }
+                    r2 = r0 + 96;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x18a78;
+                        continue;
+                    }
+                    r2 = r0 + 64;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x18a84;
+                        continue;
+                    }
+                    r2 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18a50:
+                    r3 = r3 + -64;
+                    r2 = r3 << 24;
+                    r2 = r2 >> 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18a64:
+                    r3 = r3 + -96;
+                    r2 = r3 << 24;
+                    r2 = r2 >> 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18a78:
+                    r2 = r0 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18a84:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x18c00:
+                    pc=0x18c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_18c00() throws ExecutionException { /* 0x18c00 - 0x18e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x18c00:
+                    r2 = readPages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff];
+                    r4 = r4 << 24;
+                    r25 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x18e00:
+                    pc=0x18e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_18e00() throws ExecutionException { /* 0x18e00 - 0x19000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x18e00:
+                    r2 = r28 + -32348;
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x19000:
+                    pc=0x19000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_19000() throws ExecutionException { /* 0x19000 - 0x19200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x19000:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = 7 << 16;
+                    r5 = r5 + 12832;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x19028;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x19028:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19084;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r0 + 1;
+                    r6 = r0 + 256;
+                    r7 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1904c;
+                    pc=0x3c600;
+                    run_3c600(); return;
+                case 0x1904c:
+                    r3 = r0 + 256;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19068;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -7760;
+                    /* Next insn is delay slot */ 
+                    r31=0x19068;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x19068:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x19084:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -6824;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x19200:
+                    pc=0x19200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_19200() throws ExecutionException { /* 0x19200 - 0x19400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x19200:
+                    r4 = readPages[(r28+-30756)>>>12][((r28+-30756)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19240;
+                        continue;
+                    }
+                case 0x19214:
+                    r6 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x19224;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x19224:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19260;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x19230:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x19240:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30756;
+                    r5 = r5 + 6008;
+                    /* Next insn is delay slot */ 
+                    r31=0x19254;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x19254:
+                    r4 = readPages[(r28+-30756)>>>12][((r28+-30756)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x19214;
+                    continue;
+                case 0x19260:
+                    r4 = 7 << 16;
+                    r4 = r4 + -7728;
+                    /* Next insn is delay slot */ 
+                    r31=0x19270;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x19270:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x19230;
+                    continue;
+                case 0x19400:
+                    pc=0x19400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_19400() throws ExecutionException { /* 0x19400 - 0x19600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x19400:
+                    r29 = r29 + -88;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r19;
+                    r19 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r29 + 40;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r16;
+                    r5 = r19 + r0;
+                    r16 = r4 + r0;
+                    r6 = r0 + 20;
+                    r4 = r3 + r0;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r31;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r18;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x19438;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x19438:
+                    r3 = r2 + r0;
+                    r2 = r0 + 1;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 80;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    r6 = r0 + 1;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x19474;
+                    pc=0x2f600;
+                    run_2f600(); return;
+                case 0x19474:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19540;
+                        continue;
+                    }
+                    r2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1951c;
+                        continue;
+                    }
+                    r18 = 7 << 16;
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = r0 + 125;
+                    r18 = r18 + -7708;
+                case 0x194a4:
+                    r3 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r3 + r2;
+                    r5 = r29 + 16;
+                    r6 = r0 + 1;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x194c4;
+                    pc=0x2f600;
+                    run_2f600(); return;
+                case 0x194c4:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x194e8;
+                    pc=0x1a400;
+                    run_1a400(); return;
+                case 0x194e8:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    if(r5 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19504;
+                        continue;
+                    }
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x19504;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x19504:
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r3 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = r2 < r3 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x194a4;
+                        continue;
+                    }
+                case 0x1951c:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r18 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r17 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r16 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r19;
+                    r19 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x19540:
+                    r18 = 7 << 16;
+                    r17 = r0 + 125;
+                    r18 = r18 + -7708;
+                case 0x1954c:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x19570;
+                    pc=0x1a400;
+                    run_1a400(); return;
+                case 0x19570:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    if(r5 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1958c;
+                        continue;
+                    }
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1958c;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1958c:
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r3 + r2;
+                    r5 = r29 + 16;
+                    r6 = r0 + 1;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x195b0;
+                    pc=0x2f600;
+                    run_2f600(); return;
+                case 0x195b0:
+                    r3 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r2 = r3 + r2;
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1954c;
+                        continue;
+                    }
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r18 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r17 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r16 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r19;
+                    r19 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x19600:
+                    pc=0x19600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_19600() throws ExecutionException { /* 0x19600 - 0x19800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x19600:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r29 = r29 + -40;
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r17 = r5 << 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r17 = r17 >> 24;
+                    r16 = r4 + r0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = r0;
+                    if(r2 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x196b8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x1964c;
+                    pc=0x1f400;
+                    run_1f400(); return;
+                case 0x1964c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x196b8;
+                        continue;
+                    }
+                    r18 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r19 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    r5 = r5 + -7684;
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x19670;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x19670:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x196d8;
+                        continue;
+                    }
+                case 0x19678:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 32;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19704;
+                        continue;
+                    }
+                case 0x19688:
+                    r4 = r17 + r0;
+                    writePages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x19698;
+                    pc=0x1d800;
+                    run_1d800(); return;
+                case 0x19698:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x196a8;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x196a8:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x196b4;
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x196b4:
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                case 0x196b8:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x196d8:
+                    r5 = 7 << 16;
+                    r4 = r19 + r0;
+                    r5 = r5 + -7676;
+                    /* Next insn is delay slot */ 
+                    r31=0x196ec;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x196ec:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19718;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x19678;
+                    continue;
+                case 0x19704:
+                    /* Next insn is delay slot */ 
+                    r31=0x1970c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1970c:
+                    r18 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x19688;
+                    continue;
+                case 0x19718:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x19800:
+                    pc=0x19800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_19800() throws ExecutionException { /* 0x19800 - 0x19a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x19800:
+                    r29 = r29 + -88;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r20;
+                    r20 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r29 + 40;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r16;
+                    r5 = r20 + r0;
+                    r16 = r4 + r0;
+                    r6 = r0 + 20;
+                    r4 = r3 + r0;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r19;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r18;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r17;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x1983c;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x1983c:
+                    r3 = r2 + r0;
+                    r19 = 7 << 16;
+                    r2 = r0 + 1;
+                    r18 = 7 << 16;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r2;
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r3;
+                    r2 = r3 + r0;
+                    r19 = r19 + -6980;
+                    r17 = r0 + 125;
+                    r18 = r18 + -7708;
+                case 0x19864:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x198cc;
+                        continue;
+                    }
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    r31=0x19888;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x19888:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x19894;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x19894:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x199d8;
+                        continue;
+                    }
+                case 0x198a4:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x199a8;
+                        continue;
+                    }
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = (r2&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                case 0x198c0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1997c;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x198cc:
+                    r3 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x198ec;
+                    pc=0x1a400;
+                    run_1a400(); return;
+                case 0x198ec:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    if(r5 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19908;
+                        continue;
+                    }
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x19908;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x19908:
+                    r2 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19970;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r2;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    r31=0x19930;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x19930:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x1993c;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x1993c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x199ec;
+                        continue;
+                    }
+                case 0x1994c:
+                    r2 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x199bc;
+                        continue;
+                    }
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = (r2&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1997c;
+                        continue;
+                    }
+                case 0x19970:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x19864;
+                    continue;
+                case 0x1997c:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r19 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r18 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r17 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r16 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r20;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r20 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x199a8:
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = ((r0 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x198c0;
+                    continue;
+                case 0x199bc:
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = ((r0 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19970;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1997c;
+                    continue;
+                case 0x199d8:
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x199e4;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x199e4:
+                    /* Next insn is delay slot */ 
+                    pc=0x198a4;
+                    continue;
+                case 0x199ec:
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x199f8;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x199f8:
+                    /* Next insn is delay slot */ 
+                    pc=0x1994c;
+                    continue;
+                case 0x19a00:
+                    pc=0x19a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_19a00() throws ExecutionException { /* 0x19a00 - 0x19c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x19a00:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19a58;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x19a20;
+                    pc=0x1d400;
+                    run_1d400(); return;
+                case 0x19a20:
+                    /* Next insn is delay slot */ 
+                    r31=0x19a28;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x19a28:
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19a94;
+                        continue;
+                    }
+                case 0x19a34:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19aac;
+                        continue;
+                    }
+                case 0x19a44:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x19a58:
+                    /* Next insn is delay slot */ 
+                    r31=0x19a60;
+                    pc=0x1a400;
+                    run_1a400(); return;
+                case 0x19a60:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 125;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19a20;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6912;
+                    /* Next insn is delay slot */ 
+                    r31=0x19a80;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x19a80:
+                    /* Next insn is delay slot */ 
+                    r31=0x19a88;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x19a88:
+                    r3 = r0 + 32;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19a34;
+                        continue;
+                    }
+                case 0x19a94:
+                    /* Next insn is delay slot */ 
+                    r31=0x19a9c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x19a9c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19a44;
+                        continue;
+                    }
+                case 0x19aac:
+                    /* Next insn is delay slot */ 
+                    r31=0x19ab4;
+                    pc=0x1f400;
+                    run_1f400(); return;
+                case 0x19ab4:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19b24;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = r5 + -7668;
+                    /* Next insn is delay slot */ 
+                    r31=0x19ad4;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x19ad4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19b70;
+                        continue;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19b88;
+                        continue;
+                    }
+                case 0x19aec:
+                    r3 = r0 + 123;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19b08;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6860;
+                    /* Next insn is delay slot */ 
+                    r31=0x19b08;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x19b08:
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19b38;
+                        continue;
+                    }
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x19b1c;
+                    pc=0x1d400;
+                    run_1d400(); return;
+                case 0x19b1c:
+                    /* Next insn is delay slot */ 
+                    r31=0x19b24;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x19b24:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x19b38:
+                    /* Next insn is delay slot */ 
+                    r31=0x19b40;
+                    pc=0x1a400;
+                    run_1a400(); return;
+                case 0x19b40:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 125;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19b1c;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6912;
+                    /* Next insn is delay slot */ 
+                    r31=0x19b60;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x19b60:
+                    /* Next insn is delay slot */ 
+                    r31=0x19b68;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x19b68:
+                    /* Next insn is delay slot */ 
+                    pc=0x19b24;
+                    continue;
+                case 0x19b70:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x19b80;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x19b80:
+                    /* Next insn is delay slot */ 
+                    pc=0x19b24;
+                    continue;
+                case 0x19b88:
+                    /* Next insn is delay slot */ 
+                    r31=0x19b90;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x19b90:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x19aec;
+                    continue;
+                case 0x19c00:
+                    pc=0x19c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_19c00() throws ExecutionException { /* 0x19c00 - 0x19e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x19c00:
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    r2 = r2 < 3 ? 1 : 0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    r17 = r5 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19c80;
+                        continue;
+                    }
+                case 0x19c28:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x19c38;
+                    pc=0x1be00;
+                    run_1be00(); return;
+                case 0x19c38:
+                    /* Next insn is delay slot */ 
+                    r31=0x19c40;
+                    pc=0x1a400;
+                    run_1a400(); return;
+                case 0x19c40:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 13;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19c60;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -7632;
+                    /* Next insn is delay slot */ 
+                    r31=0x19c60;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x19c60:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x19c80:
+                    r4 = 7 << 16;
+                    r4 = r4 + -7660;
+                    /* Next insn is delay slot */ 
+                    r31=0x19c90;
+                    pc=0x3fc00;
+                    run_3fc00(); return;
+                case 0x19c90:
+                    /* Next insn is delay slot */ 
+                    pc=0x19c28;
+                    continue;
+                case 0x19e00:
+                    pc=0x19e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_19e00() throws ExecutionException { /* 0x19e00 - 0x1a000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x19e00:
+                    r2 = readPages[(r28+-30748)>>>12][((r28+-30748)>>>2)&0x3ff];
+                    r29 = r29 + -40;
+                    r6 = r5 + r0;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x19e64;
+                        continue;
+                    }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7568;
+                    /* Next insn is delay slot */ 
+                    r31=0x19e54;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x19e54:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x19e64:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r8 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7596;
+                    r6 = r8 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x19ea0;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x19ea0:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1a000:
+                    pc=0x1a000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1a000() throws ExecutionException { /* 0x1a000 - 0x1a200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1a000:
+                    r29 = r29 + -24;
+                    r4 = r0 + 1;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a014;
+                    pc=0x11800;
+                    run_11800(); return;
+                case 0x1a014:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a020;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x1a020:
+                case 0x1a200:
+                    pc=0x1a200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1a200() throws ExecutionException { /* 0x1a200 - 0x1a400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1a200:
+                    r2 = readPages[(r28+-30748)>>>12][((r28+-30748)>>>2)&0x3ff];
+                    r29 = r29 + -40;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a28c;
+                        continue;
+                    }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + -6980;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7568;
+                    r6 = r6 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a260;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1a260:
+                    r2 = readPages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-32340)>>>12][((r28+-32340)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff] = r2;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a2dc;
+                        continue;
+                    }
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1a28c:
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r3 = r3 + 1168;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + -6980;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7596;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a2d4;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1a2d4:
+                    /* Next insn is delay slot */ 
+                    pc=0x1a260;
+                    continue;
+                case 0x1a2dc:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a2e4;
+                    pc=0x1a000;
+                    run_1a000(); return;
+                case 0x1a2e4:
+                case 0x1a400:
+                    pc=0x1a400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1a400() throws ExecutionException { /* 0x1a400 - 0x1a600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1a400:
+                    r29 = r29 + -72;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r31;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r23;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r22;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r21;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r20;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r19;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r18;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r17;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a430;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a430:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 125;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a4f8;
+                        continue;
+                    }
+                    r3 = r0 + 13;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a4f8;
+                        continue;
+                    }
+                    r21 = 7 << 16;
+                    r20 = 7 << 16;
+                    r23 = 7 << 16;
+                    r21 = r21 + -7236;
+                    r20 = r20 + -6980;
+                    r22 = 7 << 16;
+                    r19 = 7 << 16;
+                    r23 = r23 + -7524;
+                case 0x1a46c:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a478;
+                    pc=0x31e00;
+                    run_31e00(); return;
+                case 0x1a478:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r16 = r0 + r0;
+                case 0x1a480:
+                    r2 = r2 & 255;
+                    r3 = (r2&0xffffffffL) < (47&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a75c;
+                        run_1a600(); return;
+                    }
+                    r4 = 7 << 16;
+                    r3 = r2 << 2;
+                    r4 = r4 + -7424;
+                    r3 = r4 + r3;
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    return;
+                case 0x1a4b0:
+                    r16 = r16 | 1;
+                case 0x1a4b4:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a4bc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a4bc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        continue;
+                    }
+                case 0x1a4cc:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a4d4;
+                    pc=0x28400;
+                    run_28400(); return;
+                case 0x1a4d4:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a4dc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a4dc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 125;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a4f8;
+                        continue;
+                    }
+                    r3 = r0 + 13;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a46c;
+                        continue;
+                    }
+                case 0x1a4f8:
+                    r31 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r23 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r22 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r21 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r20 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r19 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r18 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r17 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r16 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 72;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1a528:
+                    r2 = r16 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a6c4;
+                        run_1a600(); return;
+                    }
+                    r16 = r16 | 2;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a540;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a540:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a548;
+                    pc=0x1ec00;
+                    run_1ec00(); return;
+                case 0x1a548:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a810;
+                        run_1a800(); return;
+                    }
+                case 0x1a550:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                case 0x1a558:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    continue;
+                case 0x1a568:
+                    r2 = r16 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a6c4;
+                        run_1a600(); return;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r16 = r16 | 2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r2 = r0 + r0;
+                    r18 = r0 + 45;
+                    r17 = r0 + 45;
+                    /* Next insn is delay slot */ 
+                    pc=0x1a5c0;
+                    continue;
+                case 0x1a594:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a5b0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a5b0:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    if(r2 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a60c;
+                        run_1a600(); return;
+                    }
+                case 0x1a5bc:
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                case 0x1a5c0:
+                    r3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a594;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x1a5d8;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1a5d8:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a600;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a600:
+                    pc=0x1a600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1a600() throws ExecutionException { /* 0x1a600 - 0x1a800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1a600:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    if(r2 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a5bc;
+                        run_1a400(); return;
+                    }
+                case 0x1a60c:
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a618;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1a618:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r6 = r0 + r0;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a634;
+                    pc=0x2f800;
+                    run_2f800(); return;
+                case 0x1a634:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        run_1a400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    run_1a400(); return;
+                case 0x1a64c:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a654;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a654:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 46;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a680;
+                        continue;
+                    }
+                    r2 = r2 & 255;
+                    r2 = r2 + r21;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a880;
+                        run_1a800(); return;
+                    }
+                case 0x1a680:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a688;
+                    pc=0x20a00;
+                    run_20a00(); return;
+                case 0x1a688:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        run_1a400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    run_1a400(); return;
+                case 0x1a6a0:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a6a8;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a6a8:
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a9cc;
+                        run_1a800(); return;
+                    }
+                case 0x1a6b4:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 61;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a99c;
+                        run_1a800(); return;
+                    }
+                case 0x1a6c4:
+                    r2 = readPages[(r28+-30748)>>>12][((r28+-30748)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a83c;
+                        run_1a800(); return;
+                    }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = r22 + -7568;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r20;
+                    r6 = r19 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a70c;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1a70c:
+                    r2 = readPages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-32340)>>>12][((r28+-32340)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff] = r2;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1aac0;
+                        run_1aa00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x1a730;
+                    pc=0x1c800;
+                    run_1c800(); return;
+                case 0x1a730:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1a558;
+                    run_1a400(); return;
+                case 0x1a73c:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a744;
+                    pc=0x2e200;
+                    run_2e200(); return;
+                case 0x1a744:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        run_1a400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    run_1a400(); return;
+                case 0x1a75c:
+                    r2 = r21 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a6c4;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    r17 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1a788;
+                    pc=0x1ec00;
+                    run_1ec00(); return;
+                case 0x1a788:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x1a794;
+                    return;
+                case 0x1a794:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a550;
+                        run_1a400(); return;
+                    }
+                    r2 = r16 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a9dc;
+                        run_1a800(); return;
+                    }
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r4 = r0 + -96;
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r16 = r16 | 2;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1aa14;
+                        run_1aa00(); return;
+                    }
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a7e8;
+                        continue;
+                    }
+                    r2 = r0 + -62;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1aa04;
+                        run_1aa00(); return;
+                    }
+                case 0x1a7e8:
+                    r4 = r0 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a7f8;
+                    pc=0x2fc00;
+                    run_2fc00(); return;
+                case 0x1a7f8:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                case 0x1a800:
+                    pc=0x1a800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1a800() throws ExecutionException { /* 0x1a800 - 0x1aa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1a800:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        run_1a400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    run_1a400(); return;
+                case 0x1a810:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1a824;
+                    pc=0x2fc00;
+                    run_2fc00(); return;
+                case 0x1a824:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        run_1a400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    run_1a400(); return;
+                case 0x1a83c:
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r3 = r19 + 1168;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r20;
+                    r5 = r5 + -7596;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a878;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1a878:
+                    /* Next insn is delay slot */ 
+                    pc=0x1a70c;
+                    run_1a600(); return;
+                case 0x1a880:
+                    r2 = r16 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a9dc;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + 43;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a8a0;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1a8a0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 43;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a948;
+                        continue;
+                    }
+                    r18 = r0 + 43;
+                    r17 = r0 + 43;
+                    /* Next insn is delay slot */ 
+                    pc=0x1a8ec;
+                    continue;
+                case 0x1a8c0:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a8dc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a8dc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a948;
+                        continue;
+                    }
+                case 0x1a8ec:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a8c0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x1a910;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1a910:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a938;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a938:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a8ec;
+                        continue;
+                    }
+                case 0x1a948:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a954;
+                    pc=0x30800;
+                    run_30800(); return;
+                case 0x1a954:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a964;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1a964:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r16 = r16 | 2;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r6 = r0 + r0;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1a984;
+                    pc=0x2f800;
+                    run_2f800(); return;
+                case 0x1a984:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        run_1a400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    run_1a400(); return;
+                case 0x1a99c:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a9a4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a9a4:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a9ac;
+                    pc=0x2de00;
+                    run_2de00(); return;
+                case 0x1a9ac:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a9b4;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x1a9b4:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        run_1a400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    run_1a400(); return;
+                case 0x1a9cc:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a9d4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1a9d4:
+                    /* Next insn is delay slot */ 
+                    pc=0x1a6b4;
+                    run_1a600(); return;
+                case 0x1a9dc:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a9e4;
+                    pc=0x1a200;
+                    run_1a200(); return;
+                case 0x1a9e4:
+                    /* Next insn is delay slot */ 
+                    r31=0x1a9ec;
+                    pc=0x1c800;
+                    run_1c800(); return;
+                case 0x1a9ec:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a480;
+                        run_1a400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1a4cc;
+                    run_1a400(); return;
+                case 0x1aa00:
+                    pc=0x1aa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1aa00() throws ExecutionException { /* 0x1aa00 - 0x1ac00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1aa00:
+                case 0x1aa04:
+                    addr=r5+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a7e8;
+                        run_1a600(); return;
+                    }
+                case 0x1aa14:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1a7e8;
+                        run_1a600(); return;
+                    }
+                    r2 = readPages[(r28+-30748)>>>12][((r28+-30748)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1aa78;
+                        continue;
+                    }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r23;
+                    r5 = r22 + -7568;
+                    r6 = r6 + -7532;
+                    /* Next insn is delay slot */ 
+                    r31=0x1aa70;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1aa70:
+                    /* Next insn is delay slot */ 
+                    pc=0x1a7e8;
+                    run_1a600(); return;
+                case 0x1aa78:
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r3 = r3 + -7532;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r23;
+                    r5 = r5 + -7596;
+                    /* Next insn is delay slot */ 
+                    r31=0x1aab8;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1aab8:
+                    /* Next insn is delay slot */ 
+                    pc=0x1a7e8;
+                    run_1a600(); return;
+                case 0x1aac0:
+                    /* Next insn is delay slot */ 
+                    r31=0x1aac8;
+                    pc=0x1a000;
+                    run_1a000(); return;
+                case 0x1aac8:
+                case 0x1ac00:
+                    pc=0x1ac00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1ac00() throws ExecutionException { /* 0x1ac00 - 0x1ae00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1ac00:
+                    r2 = readPages[(r28+-30748)>>>12][((r28+-30748)>>>2)&0x3ff];
+                    r29 = r29 + -40;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ac68;
+                        continue;
+                    }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7568;
+                    r6 = r6 + -7532;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ac58;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1ac58:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1ac68:
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r3 = r3 + -7532;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7596;
+                    /* Next insn is delay slot */ 
+                    r31=0x1aca8;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1aca8:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1ae00:
+                    pc=0x1ae00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1ae00() throws ExecutionException { /* 0x1ae00 - 0x1b000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1ae00:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r29 = r29 + -40;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ae24;
+                        continue;
+                    }
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1ae24:
+                    r2 = readPages[(r28+-30748)>>>12][((r28+-30748)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ae84;
+                        continue;
+                    }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7568;
+                    r6 = r6 + -7532;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ae74;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1ae74:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1ae84:
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r3 = r3 + -7532;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7596;
+                    /* Next insn is delay slot */ 
+                    r31=0x1aec4;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1aec4:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1b000:
+                    pc=0x1b000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1b000() throws ExecutionException { /* 0x1b000 - 0x1b200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1b000:
+                    r2 = readPages[(r28+-30748)>>>12][((r28+-30748)>>>2)&0x3ff];
+                    r29 = r29 + -40;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1b084;
+                        continue;
+                    }
+                    r7 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7568;
+                    r6 = r6 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b058;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1b058:
+                    r2 = readPages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-32340)>>>12][((r28+-32340)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff] = r2;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1b0cc;
+                        continue;
+                    }
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1b084:
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r7 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r3 = r3 + 1168;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-30744)>>>12][((r28+-30744)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r5 = r5 + -7596;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b0c4;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1b0c4:
+                    /* Next insn is delay slot */ 
+                    pc=0x1b058;
+                    continue;
+                case 0x1b0cc:
+                    /* Next insn is delay slot */ 
+                    r31=0x1b0d4;
+                    pc=0x1a000;
+                    run_1a000(); return;
+                case 0x1b0d4:
+                case 0x1b200:
+                    pc=0x1b200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1b200() throws ExecutionException { /* 0x1b200 - 0x1b400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1b200:
+                    r5 = 7 << 16;
+                    r29 = r29 + -24;
+                    r5 = r5 + -7476;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b218;
+                    pc=0x19e00;
+                    run_19e00(); return;
+                case 0x1b218:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b224;
+                    pc=0x11800;
+                    run_11800(); return;
+                case 0x1b224:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b230;
+                    pc=0x38e00;
+                    run_38e00(); return;
+                case 0x1b230:
+                case 0x1b400:
+                    pc=0x1b400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1b400() throws ExecutionException { /* 0x1b400 - 0x1b600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1b400:
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b410;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x1b410:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1b428;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1b428:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b438;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x1b438:
+                case 0x1b600:
+                    pc=0x1b600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1b600() throws ExecutionException { /* 0x1b600 - 0x1b800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1b600:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -24;
+                    r3 = r0 + 32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1b66c;
+                        continue;
+                    }
+                case 0x1b618:
+                    r3 = r0 + 123;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1b638;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1b638:
+                    /* Next insn is delay slot */ 
+                    r31=0x1b640;
+                    pc=0x1a400;
+                    run_1a400(); return;
+                case 0x1b640:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 125;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1b680;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x1b658;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1b658:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1b66c:
+                    /* Next insn is delay slot */ 
+                    r31=0x1b674;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1b674:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b618;
+                    continue;
+                case 0x1b680:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6912;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b690;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x1b690:
+                case 0x1b800:
+                    pc=0x1b800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1b800() throws ExecutionException { /* 0x1b800 - 0x1ba00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1b800:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = r5 + r0;
+                    r16 = r4 + r0;
+                    r5 = 7 << 16;
+                    r4 = 7 << 16;
+                    r4 = r4 + -7460;
+                    r5 = r5 + -7532;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b830;
+                    pc=0x19e00;
+                    run_19e00(); return;
+                case 0x1b830:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r5 = r5 + -7432;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b84c;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1b84c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1b858;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x1b858:
+                case 0x1ba00:
+                    pc=0x1ba00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1ba00() throws ExecutionException { /* 0x1ba00 - 0x1bc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1ba00:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r29 = r29 + -80;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r31;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r21;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r20;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r19;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r18;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r16;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1bacc;
+                        continue;
+                    }
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r5 = r5 + -6800;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ba50;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1ba50:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    addr=r28+-30732;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1ba64:
+                    r3 = r0 + 10;
+                    if(r17 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1baa0;
+                        continue;
+                    }
+                    r3 = r0 + 13;
+                    if(r17 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1baa0;
+                        continue;
+                    }
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = (r3&0xffffffffL) < (1024&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1baa0;
+                        continue;
+                    }
+                    r4 = r3 + 1;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r4;
+                    r2 = r2 + r3;
+                    addr=r2+20;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1baa0:
+                    r31 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r21 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r19 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r18 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r16 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    addr=r28+-30732;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r17 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r29 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1bacc:
+                    addr=r28+-30732;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r3 = r0 + 10;
+                    if(r5 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ba64;
+                        continue;
+                    }
+                    r6 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = r5 + -6776;
+                    r6 = r6 + -1;
+                    /* Next insn is delay slot */ 
+                    r31=0x1baf8;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1baf8:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1bb8c;
+                        continue;
+                    }
+                    addr=r29+36;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+16;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r21 = r29 + 36;
+                    r20 = r29 + 16;
+                case 0x1bb20:
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r6 = r21 + r0;
+                    r5 = r5 + -6752;
+                    r7 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1bb3c;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1bb3c:
+                    r6 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = r0 + 1024;
+                    r2 = readPages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff];
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1bc28;
+                        run_1bc00(); return;
+                    }
+                case 0x1bb54:
+                    r2 = r6 + r2;
+                    r4 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    addr=r2+20;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r5 = r5 + -6780;
+                    r6 = r6 + 20;
+                    /* Next insn is delay slot */ 
+                    r31=0x1bb74;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x1bb74:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1ba64;
+                    continue;
+                case 0x1bb8c:
+                    r21 = r29 + 36;
+                    r6 = 7 << 16;
+                    r7 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r5 = r0 + 5;
+                    r6 = r6 + -6768;
+                    /* Next insn is delay slot */ 
+                    r31=0x1bbac;
+                    pc=0x41c00;
+                    run_41c00(); return;
+                case 0x1bbac:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r20 = r29 + 16;
+                    r3 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    addr=r29+16;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1bb20;
+                        continue;
+                    }
+                    r19 = 7 << 16;
+                    r18 = r20 + r0;
+                    r16 = r0 + r0;
+                    r19 = r19 + -6760;
+                case 0x1bbd4:
+                    r2 = r2 + r16;
+                    addr=r2+1044;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r4 = r18 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1bbec;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x1bbec:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    r3 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r18 = r18 + 2;
+                    r4 = ((r16 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                case 0x1bc00:
+                    pc=0x1bc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1bc00() throws ExecutionException { /* 0x1bc00 - 0x1be00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1bc00:
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1bbd4;
+                        run_1ba00(); return;
+                    }
+                    r4 = r0 + 9;
+                    if(r3 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1bb20;
+                        run_1ba00(); return;
+                    }
+                    r3 = 11822 << 16;
+                    r3 = r3 + 11776;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x1bb20;
+                    run_1ba00(); return;
+                case 0x1bc28:
+                    r2 = r0 + 1023;
+                    writePages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x1bb54;
+                    run_1ba00(); return;
+                case 0x1be00:
+                    pc=0x1be00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1be00() throws ExecutionException { /* 0x1be00 - 0x1c000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1be00:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r4;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1c000:
+                    pc=0x1c000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1c000() throws ExecutionException { /* 0x1c000 - 0x1c200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1c000:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r29 = r29 + -48;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c0a0;
+                        continue;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r4 = r3 + 1;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1c050:
+                    r3 = r0 + 10;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c074;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                case 0x1c074:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1c0a0:
+                    r21 = 7 << 16;
+                    r4 = 7 << 16;
+                    r5 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r16 = r0 + r0;
+                    r21 = r21 + -6444;
+                    r20 = r4 + -6700;
+                    r18 = r0 + -1;
+                    r19 = r0 + 13;
+                    r17 = r0 + 10;
+                case 0x1c0c4:
+                    r3 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c41c;
+                        run_1c400(); return;
+                    }
+                case 0x1c0d0:
+                    r5 = r5 << 2;
+                    r5 = r21 + r5;
+                    r3 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    return;
+                case 0x1c0e8:
+                    if(r16 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c2ec;
+                        run_1c200(); return;
+                    }
+                    if(r16 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c2ec;
+                        run_1c200(); return;
+                    }
+                    if(r16 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c2ec;
+                        run_1c200(); return;
+                    }
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1c108:
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r3;
+                    if(r3 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c304;
+                        run_1c200(); return;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r16 = tmp;
+                case 0x1c144:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c0e8;
+                        continue;
+                    }
+                    r4 = r16 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c16c;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1c16c:
+                    /* Next insn is delay slot */ 
+                    pc=0x1c0e8;
+                    continue;
+                case 0x1c174:
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r3;
+                    if(r3 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c51c;
+                        run_1c400(); return;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r16 = tmp;
+                case 0x1c1b0:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c1d8;
+                        continue;
+                    }
+                    r4 = r16 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c1d8;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1c1d8:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1c1dc:
+                    r3 = r0 + -1;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    if(r16 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c478;
+                        run_1c400(); return;
+                    }
+                    r4 = 7 << 16;
+                    r3 = r16 & 255;
+                    r4 = r4 + -7236;
+                    r3 = r3 + r4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                case 0x1c200:
+                    pc=0x1c200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1c200() throws ExecutionException { /* 0x1c200 - 0x1c400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1c200:
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c25c;
+                        continue;
+                    }
+                    r3 = r0 + 32;
+                    if(r16 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c460;
+                        run_1c400(); return;
+                    }
+                    r3 = r16 < 33 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c43c;
+                        run_1c400(); return;
+                    }
+                    r3 = r0 + 59;
+                    if(r16 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c4e8;
+                        run_1c400(); return;
+                    }
+                    r3 = r0 + 125;
+                    if(r16 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c4d0;
+                        run_1c400(); return;
+                    }
+                    r2 = r0 + 58;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c490;
+                        run_1c400(); return;
+                    }
+                case 0x1c24c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6740;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c25c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1c25c:
+                    r2 = r16 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c270:
+                    r20 = r0 + 9;
+                    r22 = r0 + 32;
+                case 0x1c278:
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r3;
+                    if(r3 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c400;
+                        run_1c400(); return;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r16 = tmp;
+                case 0x1c2b4:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c2dc;
+                        continue;
+                    }
+                    r4 = r16 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c2dc;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1c2dc:
+                    if(r16 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c320;
+                        continue;
+                    }
+                    if(r16 == r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c320;
+                        continue;
+                    }
+                case 0x1c2ec:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c0d0;
+                    run_1c000(); return;
+                case 0x1c304:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1c314;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1c314:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c144;
+                    run_1c000(); return;
+                case 0x1c320:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1c278;
+                    continue;
+                case 0x1c32c:
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 10;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c340:
+                    r3 = r0 + 5;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 10;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c358:
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r3;
+                    if(r3 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c500;
+                        run_1c400(); return;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r16 = tmp;
+                case 0x1c394:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c3bc;
+                        continue;
+                    }
+                    r4 = r16 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c3bc;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1c3bc:
+                    if(r16 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c2ec;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c0d0;
+                    run_1c000(); return;
+                case 0x1c3d8:
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 125;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c3ec:
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 13;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c400:
+                    pc=0x1c400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1c400() throws ExecutionException { /* 0x1c400 - 0x1c600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1c400:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1c410;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1c410:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c2b4;
+                    run_1c200(); return;
+                case 0x1c41c:
+                    r4 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c428;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1c428:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1c0c4;
+                    run_1c000(); return;
+                case 0x1c43c:
+                    r3 = r0 + 10;
+                    if(r16 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c4b8;
+                        continue;
+                    }
+                    r3 = r0 + 13;
+                    if(r16 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c4a0;
+                        continue;
+                    }
+                    r3 = r0 + 9;
+                    if(r16 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c24c;
+                        run_1c200(); return;
+                    }
+                case 0x1c460:
+                    r3 = r0 + 2;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 32;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c478:
+                    r3 = r0 + 8;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c490:
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c4a0:
+                    r3 = r0 + 4;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c4b8:
+                    r3 = r0 + 3;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c4d0:
+                    r3 = r0 + 7;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c4e8:
+                    r3 = r0 + 6;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c050;
+                    run_1c000(); return;
+                case 0x1c500:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1c510;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1c510:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c394;
+                    run_1c200(); return;
+                case 0x1c51c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1c52c;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1c52c:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c1b0;
+                    run_1c000(); return;
+                case 0x1c600:
+                    pc=0x1c600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1c600() throws ExecutionException { /* 0x1c600 - 0x1c800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1c600:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c654;
+                        continue;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r4 = r3 + 1;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1c638:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c700;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1c654:
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r3;
+                    if(r3 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c754;
+                        continue;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r16 = tmp;
+                case 0x1c690:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c6b8;
+                        continue;
+                    }
+                    r4 = r16 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c6b8;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1c6b8:
+                    r2 = r0 + 10;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c6f0;
+                        continue;
+                    }
+                    r2 = r0 + 13;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c770;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c728;
+                        continue;
+                    }
+                    r2 = r16 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c638;
+                    continue;
+                case 0x1c6f0:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 3;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1c700:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6680;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c710;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1c710:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                case 0x1c714:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1c728:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 8;
+                    r4 = 7 << 16;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r4 + -6680;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c748;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1c748:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c714;
+                    continue;
+                case 0x1c754:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1c764;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1c764:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c690;
+                    continue;
+                case 0x1c770:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 4;
+                    r4 = 7 << 16;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r4 + -6680;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c790;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1c790:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c714;
+                    continue;
+                case 0x1c800:
+                    pc=0x1c800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1c800() throws ExecutionException { /* 0x1c800 - 0x1ca00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1c800:
+                    r29 = r29 + -56;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r23;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    r23 = 7 << 16;
+                    r21 = 7 << 16;
+                    r22 = 7 << 16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r21 = r21 + -6408;
+                    r23 = r23 + -6700;
+                    r22 = r22 + -7236;
+                case 0x1c848:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c8b0;
+                        continue;
+                    }
+                case 0x1c850:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c8e4;
+                        continue;
+                    }
+                    r2 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1c884:
+                    r3 = r0 + 10;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c848;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c850;
+                        continue;
+                    }
+                case 0x1c8b0:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1c8e4:
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r30 = r0 + r0;
+                    r17 = r0 + -1;
+                    r18 = r0 + 13;
+                    r16 = r0 + 10;
+                case 0x1c8f8:
+                    r4 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cc5c;
+                        run_1cc00(); return;
+                    }
+                case 0x1c904:
+                    r5 = r5 << 2;
+                    r5 = r21 + r5;
+                    r4 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r4;
+                    return;
+                case 0x1c91c:
+                    if(r30 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c9a8;
+                        continue;
+                    }
+                case 0x1c924:
+                    if(r30 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c9a8;
+                        continue;
+                    }
+                    if(r30 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c9a8;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1c93c:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cab4;
+                        run_1ca00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1c978:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c91c;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1c9a0;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1c9a0:
+                    if(r30 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c924;
+                        continue;
+                    }
+                case 0x1c9a8:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r4;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c904;
+                    continue;
+                case 0x1c9c0:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cd40;
+                        run_1cc00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1c9fc:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                case 0x1ca00:
+                    pc=0x1ca00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1ca00() throws ExecutionException { /* 0x1ca00 - 0x1cc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1ca00:
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ca24;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ca24;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1ca24:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1ca28:
+                    r4 = r0 + -1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cce8;
+                        run_1cc00(); return;
+                    }
+                    r4 = r30 & 255;
+                    r4 = r4 + r22;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1caa0;
+                        continue;
+                    }
+                    r4 = r0 + 32;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cca0;
+                        run_1cc00(); return;
+                    }
+                    r4 = r30 < 33 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cc7c;
+                        run_1cc00(); return;
+                    }
+                    r4 = r0 + 59;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ccb8;
+                        run_1cc00(); return;
+                    }
+                    r4 = r0 + 125;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cd28;
+                        run_1cc00(); return;
+                    }
+                    r3 = r0 + 58;
+                    if(r30 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cd18;
+                        run_1cc00(); return;
+                    }
+                case 0x1ca90:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6740;
+                    /* Next insn is delay slot */ 
+                    r31=0x1caa0;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1caa0:
+                    r2 = r30 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cab4:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1cac4;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1cac4:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c978;
+                    run_1c800(); return;
+                case 0x1cad0:
+                    r2 = r0 + 125;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cae4:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cd5c;
+                        run_1cc00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1cb20:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cb48;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1cb48;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1cb48:
+                    if(r30 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c9a8;
+                        run_1c800(); return;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c904;
+                    run_1c800(); return;
+                case 0x1cb64:
+                    r2 = r0 + 5;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 10;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cb7c:
+                    r2 = r0 + 10;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cb90:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r19 = r0 + 9;
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r20 = r0 + 32;
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cc2c;
+                        run_1cc00(); return;
+                    }
+                case 0x1cbb0:
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1cbcc:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cbf4;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1cbf4;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1cbf4:
+                    if(r30 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cc04;
+                        run_1cc00(); return;
+                    }
+                    if(r30 != r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1c9a8;
+                        run_1c800(); return;
+                    }
+                case 0x1cc00:
+                    pc=0x1cc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1cc00() throws ExecutionException { /* 0x1cc00 - 0x1ce00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1cc00:
+                case 0x1cc04:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cbb0;
+                        run_1ca00(); return;
+                    }
+                case 0x1cc2c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1cc3c;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1cc3c:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cbcc;
+                    run_1ca00(); return;
+                case 0x1cc48:
+                    r2 = r0 + 13;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cc5c:
+                    r4 = r23 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1cc68;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1cc68:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1c8f8;
+                    run_1c800(); return;
+                case 0x1cc7c:
+                    r4 = r0 + 10;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ccd0;
+                        continue;
+                    }
+                    r4 = r0 + 13;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cd00;
+                        continue;
+                    }
+                    r4 = r0 + 9;
+                    if(r30 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ca90;
+                        run_1ca00(); return;
+                    }
+                case 0x1cca0:
+                    r2 = r0 + 2;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 32;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1ccb8:
+                    r2 = r0 + 6;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1ccd0:
+                    r2 = r0 + 3;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cce8:
+                    r2 = r0 + 8;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cd00:
+                    r2 = r0 + 4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cd18:
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cd28:
+                    r2 = r0 + 7;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c884;
+                    run_1c800(); return;
+                case 0x1cd40:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1cd50;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1cd50:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1c9fc;
+                    run_1c800(); return;
+                case 0x1cd5c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1cd6c;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1cd6c:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cb20;
+                    run_1ca00(); return;
+                case 0x1ce00:
+                    pc=0x1ce00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1ce00() throws ExecutionException { /* 0x1ce00 - 0x1d000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1ce00:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -56;
+                    r3 = r0 + 32;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r23;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d284;
+                        run_1d200(); return;
+                    }
+                case 0x1ce3c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ce78;
+                        continue;
+                    }
+                case 0x1ce44:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1ce78:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6644;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ce88;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1ce88:
+                    r21 = 7 << 16;
+                    r23 = 7 << 16;
+                    r22 = 7 << 16;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r21 = r21 + -6372;
+                    r23 = r23 + -6700;
+                    r22 = r22 + -7236;
+                case 0x1cea4:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ce44;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cf0c;
+                        continue;
+                    }
+                    r2 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1cee0:
+                    r3 = r0 + 10;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cea4;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cea4;
+                    continue;
+                case 0x1cf0c:
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r30 = r0 + r0;
+                    r17 = r0 + -1;
+                    r18 = r0 + 13;
+                    r16 = r0 + 10;
+                case 0x1cf20:
+                    r4 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d298;
+                        run_1d200(); return;
+                    }
+                case 0x1cf2c:
+                    r5 = r5 << 2;
+                    r5 = r21 + r5;
+                    r4 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r4;
+                    return;
+                case 0x1cf44:
+                    if(r30 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d138;
+                        run_1d000(); return;
+                    }
+                    if(r30 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d138;
+                        run_1d000(); return;
+                    }
+                    if(r30 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d138;
+                        run_1d000(); return;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1cf64:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d150;
+                        run_1d000(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1cfa0:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1cf44;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1cfc8;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1cfc8:
+                    /* Next insn is delay slot */ 
+                    pc=0x1cf44;
+                    continue;
+                case 0x1cfd0:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d37c;
+                        run_1d200(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                case 0x1d000:
+                    pc=0x1d000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1d000() throws ExecutionException { /* 0x1d000 - 0x1d200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1d000:
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1d00c:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d034;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d034;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1d034:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1d038:
+                    r4 = r0 + -1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d2e8;
+                        run_1d200(); return;
+                    }
+                    r4 = r30 & 255;
+                    r4 = r4 + r22;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d0b0;
+                        continue;
+                    }
+                    r4 = r0 + 32;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d324;
+                        run_1d200(); return;
+                    }
+                    r4 = r30 < 33 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d2b8;
+                        run_1d200(); return;
+                    }
+                    r4 = r0 + 59;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d354;
+                        run_1d200(); return;
+                    }
+                    r4 = r0 + 125;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d300;
+                        run_1d200(); return;
+                    }
+                    r3 = r0 + 58;
+                    if(r30 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d36c;
+                        run_1d200(); return;
+                    }
+                case 0x1d0a0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6740;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d0b0;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1d0b0:
+                    r2 = r30 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d0c4:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r19 = r0 + 9;
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r20 = r0 + 32;
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d254;
+                        run_1d200(); return;
+                    }
+                case 0x1d0e4:
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1d100:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d128;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d128;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1d128:
+                    if(r30 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d22c;
+                        run_1d200(); return;
+                    }
+                    if(r30 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d22c;
+                        run_1d200(); return;
+                    }
+                case 0x1d138:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r4;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cf2c;
+                    run_1ce00(); return;
+                case 0x1d150:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1d160;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1d160:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cfa0;
+                    run_1ce00(); return;
+                case 0x1d16c:
+                    r2 = r0 + 125;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d180:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d398;
+                        run_1d200(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1d1bc:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d1e4;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d1e4;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1d1e4:
+                    if(r30 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d138;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cf2c;
+                    run_1ce00(); return;
+                case 0x1d200:
+                    pc=0x1d200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1d200() throws ExecutionException { /* 0x1d200 - 0x1d400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1d200:
+                    r2 = r0 + 5;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 10;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d218:
+                    r2 = r0 + 10;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d22c:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d0e4;
+                        run_1d000(); return;
+                    }
+                case 0x1d254:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1d264;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1d264:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1d100;
+                    run_1d000(); return;
+                case 0x1d270:
+                    r2 = r0 + 13;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d284:
+                    /* Next insn is delay slot */ 
+                    r31=0x1d28c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1d28c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1ce3c;
+                    run_1ce00(); return;
+                case 0x1d298:
+                    r4 = r23 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d2a4;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1d2a4:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1cf20;
+                    run_1ce00(); return;
+                case 0x1d2b8:
+                    r4 = r0 + 10;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d33c;
+                        continue;
+                    }
+                    r4 = r0 + 13;
+                    if(r30 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d318;
+                        continue;
+                    }
+                    r2 = r0 + 4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d2e8:
+                    r2 = r0 + 8;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d300:
+                    r2 = r0 + 7;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d318:
+                    r4 = r0 + 9;
+                    if(r30 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d0a0;
+                        run_1d000(); return;
+                    }
+                case 0x1d324:
+                    r2 = r0 + 2;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 32;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d33c:
+                    r2 = r0 + 3;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d354:
+                    r2 = r0 + 6;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d36c:
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1cee0;
+                    run_1ce00(); return;
+                case 0x1d37c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1d38c;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1d38c:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1d00c;
+                    run_1d000(); return;
+                case 0x1d398:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1d3a8;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1d3a8:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1d1bc;
+                    run_1d000(); return;
+                case 0x1d400:
+                    pc=0x1d400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1d400() throws ExecutionException { /* 0x1d400 - 0x1d600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1d400:
+                    r29 = r29 + -56;
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    r20 = 7 << 16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r23;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r16 = r4 + r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    r19 = r0 + 1;
+                    r21 = r0 + 39;
+                    r20 = r20 + -6680;
+                case 0x1d448:
+                    /* Next insn is delay slot */ 
+                    r31=0x1d450;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1d450:
+                    r23 = r2 + r0;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d48c;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d758;
+                        run_1d600(); return;
+                    }
+                case 0x1d478:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r23&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1d48c:
+                    if(r23 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d534;
+                        continue;
+                    }
+                    r2 = r23 < 40 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d6e4;
+                        run_1d600(); return;
+                    }
+                    r2 = r0 + 123;
+                    if(r23 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d744;
+                        run_1d600(); return;
+                    }
+                    r2 = r0 + 125;
+                    if(r23 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d4bc;
+                        continue;
+                    }
+                    r19 = r19 + -1;
+                case 0x1d4bc:
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d448;
+                        continue;
+                    }
+                case 0x1d4c4:
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d774;
+                        run_1d600(); return;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d4dc;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1d4dc:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + 13;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d4ec;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1d4ec:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x1d524:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6912;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d534;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x1d534:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r17 = r0 + 10;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r22 = r0 + 3;
+                    r18 = r0 + 13;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d5e0;
+                        continue;
+                    }
+                case 0x1d550:
+                    r2 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r30 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r30&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r30 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d688;
+                        run_1d600(); return;
+                    }
+                case 0x1d574:
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d5b0;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d70c;
+                        run_1d600(); return;
+                    }
+                case 0x1d598:
+                    r2 = r3 + 1;
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r5 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1d5b0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d4bc;
+                        continue;
+                    }
+                    if(r23 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d4bc;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d550;
+                        continue;
+                    }
+                case 0x1d5e0:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d728;
+                        run_1d600(); return;
+                    }
+                case 0x1d600:
+                    pc=0x1d600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1d600() throws ExecutionException { /* 0x1d600 - 0x1d800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1d600:
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1d61c:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d644;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d644;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1d644:
+                    if(r30 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d67c;
+                        continue;
+                    }
+                    if(r30 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d6c0;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d69c;
+                        continue;
+                    }
+                    r30 = r30 << 24;
+                    r30 = r30 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r30&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d574;
+                        run_1d400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1d688;
+                    continue;
+                case 0x1d67c:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r22;
+                case 0x1d688:
+                    r4 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d694;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1d694:
+                    /* Next insn is delay slot */ 
+                    pc=0x1d574;
+                    run_1d400(); return;
+                case 0x1d69c:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 8;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r20 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d6b8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1d6b8:
+                    /* Next insn is delay slot */ 
+                    pc=0x1d574;
+                    run_1d400(); return;
+                case 0x1d6c0:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 4;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r20 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d6dc;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1d6dc:
+                    /* Next insn is delay slot */ 
+                    pc=0x1d574;
+                    run_1d400(); return;
+                case 0x1d6e4:
+                    r2 = r0 + 13;
+                    if(r23 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d524;
+                        run_1d400(); return;
+                    }
+                    r2 = r0 + 34;
+                    if(r23 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d534;
+                        run_1d400(); return;
+                    }
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d448;
+                        run_1d400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1d4c4;
+                    run_1d400(); return;
+                case 0x1d70c:
+                    /* Next insn is delay slot */ 
+                    r31=0x1d714;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1d714:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1d598;
+                    run_1d400(); return;
+                case 0x1d728:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1d738;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1d738:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1d61c;
+                    continue;
+                case 0x1d744:
+                    r19 = r19 + 1;
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d448;
+                        run_1d400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1d4c4;
+                    run_1d400(); return;
+                case 0x1d758:
+                    /* Next insn is delay slot */ 
+                    r31=0x1d760;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1d760:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1d478;
+                    run_1d400(); return;
+                case 0x1d774:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1d800:
+                    pc=0x1d800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1d800() throws ExecutionException { /* 0x1d800 - 0x1da00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1d800:
+                    r29 = r29 + -56;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r23;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r20;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r23 = tmp;
+                    r20 = r4 << 24;
+                    r20 = r20 >> 24;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r22;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    if(r23 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1da5c;
+                        run_1da00(); return;
+                    }
+                    if(r23 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1da5c;
+                        run_1da00(); return;
+                    }
+                    r18 = 7 << 16;
+                    r19 = r0 + 34;
+                    r18 = r18 + -6680;
+                    r16 = r0 + 10;
+                    r21 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x1d888;
+                    continue;
+                case 0x1d860:
+                    r2 = r0 + 39;
+                    if(r23 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d8c0;
+                        continue;
+                    }
+                case 0x1d86c:
+                    /* Next insn is delay slot */ 
+                    r31=0x1d874;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1d874:
+                    r23 = r2 + r0;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1da5c;
+                        run_1da00(); return;
+                    }
+                    if(r23 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1da5c;
+                        run_1da00(); return;
+                    }
+                case 0x1d888:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1db10;
+                        run_1da00(); return;
+                    }
+                case 0x1d8a4:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r23&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r23 != r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d860;
+                        continue;
+                    }
+                case 0x1d8c0:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r17 = r0 + 13;
+                    r4 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d964;
+                        continue;
+                    }
+                case 0x1d8d8:
+                    r2 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r22 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r22&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d9f8;
+                        continue;
+                    }
+                case 0x1d8fc:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1da20;
+                        run_1da00(); return;
+                    }
+                case 0x1d918:
+                    r5 = r4 + r0;
+                    r6 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r4 = r3 + 1;
+                    writePages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff] = r4;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r6 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1da5c;
+                        run_1da00(); return;
+                    }
+                case 0x1d944:
+                    if(r23 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d86c;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d8d8;
+                        continue;
+                    }
+                case 0x1d964:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1daf4;
+                        run_1da00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r22 = tmp;
+                case 0x1d9a0:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d9c8;
+                        continue;
+                    }
+                    r4 = r22 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1d9c8;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1d9c8:
+                    if(r22 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dad4;
+                        run_1da00(); return;
+                    }
+                    if(r22 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dab0;
+                        run_1da00(); return;
+                    }
+                    r2 = r0 + -1;
+                    if(r22 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1da8c;
+                        run_1da00(); return;
+                    }
+                    r22 = r22 << 24;
+                    r22 = r22 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r22&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d8fc;
+                        continue;
+                    }
+                case 0x1d9f8:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1da04;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1da00:
+                    pc=0x1da00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1da00() throws ExecutionException { /* 0x1da00 - 0x1dc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1da00:
+                case 0x1da04:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d918;
+                        run_1d800(); return;
+                    }
+                case 0x1da20:
+                    /* Next insn is delay slot */ 
+                    r31=0x1da28;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1da28:
+                    r5 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    r6 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r4 = r3 + 1;
+                    writePages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff] = r4;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r6 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1d944;
+                        run_1d800(); return;
+                    }
+                case 0x1da5c:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r23 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r22 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r21 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1da8c:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 8;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r18 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1daa8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1daa8:
+                    /* Next insn is delay slot */ 
+                    pc=0x1da04;
+                    continue;
+                case 0x1dab0:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 4;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r18 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1dacc;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1dacc:
+                    /* Next insn is delay slot */ 
+                    pc=0x1da04;
+                    continue;
+                case 0x1dad4:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r21;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1daec;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1daec:
+                    /* Next insn is delay slot */ 
+                    pc=0x1da04;
+                    continue;
+                case 0x1daf4:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1db04;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1db04:
+                    r22 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1d9a0;
+                    run_1d800(); return;
+                case 0x1db10:
+                    /* Next insn is delay slot */ 
+                    r31=0x1db18;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1db18:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1d8a4;
+                    run_1d800(); return;
+                case 0x1dc00:
+                    pc=0x1dc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1dc00() throws ExecutionException { /* 0x1dc00 - 0x1de00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1dc00:
+                    r29 = r29 + -56;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r23;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r23 = 7 << 16;
+                    r17 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    r16 = r0 + r0;
+                    r17 = r17 + -7236;
+                    r23 = r23 + -6336;
+                case 0x1dc44:
+                    r3 = r2 & 255;
+                    r3 = r17 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 64;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dd04;
+                        continue;
+                    }
+                case 0x1dc60:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1df24;
+                        run_1de00(); return;
+                    }
+                case 0x1dc7c:
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = r3 + 1;
+                    r3 = r5 + r3;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r6;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dd54;
+                        continue;
+                    }
+                    r2 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1dcc4:
+                    r3 = r0 + 10;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dc44;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    r3 = r2 & 255;
+                    r3 = r17 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 64;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dc60;
+                        continue;
+                    }
+                case 0x1dd04:
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dd1c;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6844;
+                    /* Next insn is delay slot */ 
+                    r31=0x1dd1c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1dd1c:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1dd54:
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r30 = r0 + r0;
+                    r19 = r0 + -1;
+                    r20 = r0 + 13;
+                    r18 = r0 + 10;
+                case 0x1dd68:
+                    r4 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e0e8;
+                        run_1e000(); return;
+                    }
+                case 0x1dd74:
+                    r5 = r5 << 2;
+                    r5 = r23 + r5;
+                    r4 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r4;
+                    return;
+                case 0x1dd8c:
+                    if(r30 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1de18;
+                        run_1de00(); return;
+                    }
+                case 0x1dd94:
+                    if(r30 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1de18;
+                        run_1de00(); return;
+                    }
+                    if(r30 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1de18;
+                        run_1de00(); return;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1ddac:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1df40;
+                        run_1de00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1dde8:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dd8c;
+                        continue;
+                    }
+                case 0x1de00:
+                    pc=0x1de00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1de00() throws ExecutionException { /* 0x1de00 - 0x1e000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1de00:
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1de10;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1de10:
+                    if(r30 != r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dd94;
+                        run_1dc00(); return;
+                    }
+                case 0x1de18:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r4;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dd74;
+                    run_1dc00(); return;
+                case 0x1de30:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e1d0;
+                        run_1e000(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1de6c:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1de94;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1de94;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1de94:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1de98:
+                    r4 = r0 + -1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e178;
+                        run_1e000(); return;
+                    }
+                    r4 = r30 & 255;
+                    r4 = r17 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1df10;
+                        continue;
+                    }
+                    r4 = r0 + 32;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e130;
+                        run_1e000(); return;
+                    }
+                    r4 = r30 < 33 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e10c;
+                        run_1e000(); return;
+                    }
+                    r4 = r0 + 59;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e148;
+                        run_1e000(); return;
+                    }
+                    r4 = r0 + 125;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e1b8;
+                        run_1e000(); return;
+                    }
+                    r3 = r0 + 58;
+                    if(r30 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e1a8;
+                        run_1e000(); return;
+                    }
+                case 0x1df00:
+                    r2 = 7 << 16;
+                    r4 = r2 + -6740;
+                    /* Next insn is delay slot */ 
+                    r31=0x1df10;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1df10:
+                    r2 = r30 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1df24:
+                    /* Next insn is delay slot */ 
+                    r31=0x1df2c;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1df2c:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1dc7c;
+                    run_1dc00(); return;
+                case 0x1df40:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1df50;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1df50:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dde8;
+                    run_1dc00(); return;
+                case 0x1df5c:
+                    r2 = r0 + 125;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1df70:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e1ec;
+                        run_1e000(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1dfac:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1dfd4;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1dfd4;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1dfd4:
+                    if(r30 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1de18;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dd74;
+                    run_1dc00(); return;
+                case 0x1dff0:
+                    r2 = r0 + 5;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 10;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1e000:
+                    pc=0x1e000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1e000() throws ExecutionException { /* 0x1e000 - 0x1e200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1e000:
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e008:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r21 = r0 + 9;
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r22 = r0 + 32;
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e0a4;
+                        continue;
+                    }
+                case 0x1e028:
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1e044:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e06c;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e06c;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1e06c:
+                    if(r30 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e07c;
+                        continue;
+                    }
+                    if(r30 != r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1de18;
+                        run_1de00(); return;
+                    }
+                case 0x1e07c:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e028;
+                        continue;
+                    }
+                case 0x1e0a4:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1e0b4;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1e0b4:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e044;
+                    continue;
+                case 0x1e0c0:
+                    r2 = r0 + 13;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e0d4:
+                    r2 = r0 + 10;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e0e8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6700;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e0f8;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1e0f8:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1dd68;
+                    run_1dc00(); return;
+                case 0x1e10c:
+                    r4 = r0 + 10;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e160;
+                        continue;
+                    }
+                    r4 = r0 + 13;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e190;
+                        continue;
+                    }
+                    r4 = r0 + 9;
+                    if(r30 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1df00;
+                        run_1de00(); return;
+                    }
+                case 0x1e130:
+                    r2 = r0 + 2;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 32;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e148:
+                    r2 = r0 + 6;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e160:
+                    r2 = r0 + 3;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e178:
+                    r2 = r0 + 8;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e190:
+                    r2 = r0 + 4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e1a8:
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e1b8:
+                    r2 = r0 + 7;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1dcc4;
+                    run_1dc00(); return;
+                case 0x1e1d0:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1e1e0;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1e1e0:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1de6c;
+                    run_1de00(); return;
+                case 0x1e1ec:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1e1fc;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1e1fc:
+                    r30 = r2 + r0;
+                case 0x1e200:
+                    pc=0x1e200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1e200() throws ExecutionException { /* 0x1e200 - 0x1e400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1e200:
+                    /* Next insn is delay slot */ 
+                    pc=0x1dfac;
+                    run_1de00(); return;
+                case 0x1e400:
+                    pc=0x1e400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1e400() throws ExecutionException { /* 0x1e400 - 0x1e600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1e400:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -64;
+                    r3 = r0 + 32;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r30;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r23;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r22;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r21;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e9c4;
+                        run_1e800(); return;
+                    }
+                case 0x1e43c:
+                    r3 = r0 + 46;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e9e0;
+                        run_1e800(); return;
+                    }
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r0;
+                case 0x1e44c:
+                    r3 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r17 = 7 << 16;
+                    r23 = 7 << 16;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r0;
+                    r16 = r0 + r0;
+                    r17 = r17 + -7236;
+                    r23 = r23 + -6300;
+                case 0x1e468:
+                    r3 = r2 & 255;
+                    r3 = r17 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 64;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e528;
+                        continue;
+                    }
+                case 0x1e484:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e758;
+                        run_1e600(); return;
+                    }
+                case 0x1e4a0:
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = r3 + 1;
+                    r3 = r5 + r3;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r6;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e588;
+                        continue;
+                    }
+                    r2 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1e4e8:
+                    r3 = r0 + 10;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e468;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    r3 = r2 & 255;
+                    r3 = r17 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 64;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e484;
+                        continue;
+                    }
+                case 0x1e528:
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e540;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6844;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e540;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1e540:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e550;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1e550:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1e588:
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r30 = r0 + r0;
+                    r19 = r0 + -1;
+                    r20 = r0 + 13;
+                    r18 = r0 + 10;
+                case 0x1e59c:
+                    r4 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e91c;
+                        run_1e800(); return;
+                    }
+                case 0x1e5a8:
+                    r5 = r5 << 2;
+                    r5 = r23 + r5;
+                    r4 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r4;
+                    return;
+                case 0x1e5c0:
+                    if(r30 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e64c;
+                        run_1e600(); return;
+                    }
+                case 0x1e5c8:
+                    if(r30 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e64c;
+                        run_1e600(); return;
+                    }
+                    if(r30 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e64c;
+                        run_1e600(); return;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1e5e0:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e774;
+                        run_1e600(); return;
+                    }
+                case 0x1e600:
+                    pc=0x1e600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1e600() throws ExecutionException { /* 0x1e600 - 0x1e800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1e600:
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1e61c:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e5c0;
+                        run_1e400(); return;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e644;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1e644:
+                    if(r30 != r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e5c8;
+                        run_1e400(); return;
+                    }
+                case 0x1e64c:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r4;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e5a8;
+                    run_1e400(); return;
+                case 0x1e664:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ea4c;
+                        run_1ea00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1e6a0:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e6c8;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e6c8;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1e6c8:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1e6cc:
+                    r4 = r0 + -1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e9ac;
+                        run_1e800(); return;
+                    }
+                    r4 = r30 & 255;
+                    r4 = r17 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e744;
+                        continue;
+                    }
+                    r4 = r0 + 32;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e964;
+                        run_1e800(); return;
+                    }
+                    r4 = r30 < 33 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e940;
+                        run_1e800(); return;
+                    }
+                    r4 = r0 + 59;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e97c;
+                        run_1e800(); return;
+                    }
+                    r4 = r0 + 125;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ea34;
+                        run_1ea00(); return;
+                    }
+                    r3 = r0 + 58;
+                    if(r30 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ea24;
+                        run_1ea00(); return;
+                    }
+                case 0x1e734:
+                    r2 = 7 << 16;
+                    r4 = r2 + -6740;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e744;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1e744:
+                    r2 = r30 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e758:
+                    /* Next insn is delay slot */ 
+                    r31=0x1e760;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1e760:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4a0;
+                    run_1e400(); return;
+                case 0x1e774:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1e784;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1e784:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e61c;
+                    continue;
+                case 0x1e790:
+                    r2 = r0 + 125;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e7a4:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ea68;
+                        run_1ea00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1e7e0:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e808;
+                        run_1e800(); return;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                case 0x1e800:
+                    pc=0x1e800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1e800() throws ExecutionException { /* 0x1e800 - 0x1ea00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1e800:
+                    /* Next insn is delay slot */ 
+                    r31=0x1e808;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1e808:
+                    if(r30 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e64c;
+                        run_1e600(); return;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e5a8;
+                    run_1e400(); return;
+                case 0x1e824:
+                    r2 = r0 + 5;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 10;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e83c:
+                    r2 = r0 + 13;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e850:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r21 = r0 + 9;
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r22 = r0 + 32;
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e8ec;
+                        continue;
+                    }
+                case 0x1e870:
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1e88c:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e8b4;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e8b4;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1e8b4:
+                    if(r30 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e8c4;
+                        continue;
+                    }
+                    if(r30 != r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e64c;
+                        run_1e600(); return;
+                    }
+                case 0x1e8c4:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e870;
+                        continue;
+                    }
+                case 0x1e8ec:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1e8fc;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1e8fc:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e88c;
+                    continue;
+                case 0x1e908:
+                    r2 = r0 + 10;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e91c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6700;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e92c;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1e92c:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1e59c;
+                    run_1e400(); return;
+                case 0x1e940:
+                    r4 = r0 + 10;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e994;
+                        continue;
+                    }
+                    r4 = r0 + 13;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ea0c;
+                        run_1ea00(); return;
+                    }
+                    r4 = r0 + 9;
+                    if(r30 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1e734;
+                        run_1e600(); return;
+                    }
+                case 0x1e964:
+                    r2 = r0 + 2;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 32;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e97c:
+                    r2 = r0 + 6;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e994:
+                    r2 = r0 + 3;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e9ac:
+                    r2 = r0 + 8;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1e9c4:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e9d0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1e9d0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1e43c;
+                    run_1e400(); return;
+                case 0x1e9e0:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    r31=0x1e9ec;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1e9ec:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                case 0x1ea00:
+                    pc=0x1ea00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1ea00() throws ExecutionException { /* 0x1ea00 - 0x1ec00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1ea00:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e44c;
+                    run_1e400(); return;
+                case 0x1ea0c:
+                    r2 = r0 + 4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1ea24:
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1ea34:
+                    r2 = r0 + 7;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e4e8;
+                    run_1e400(); return;
+                case 0x1ea4c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1ea5c;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1ea5c:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e6a0;
+                    run_1e600(); return;
+                case 0x1ea68:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1ea78;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1ea78:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1e7e0;
+                    run_1e600(); return;
+                case 0x1ec00:
+                    pc=0x1ec00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1ec00() throws ExecutionException { /* 0x1ec00 - 0x1ee00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1ec00:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -56;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r23;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    r17 = 7 << 16;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    r23 = 7 << 16;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r16 = r0 + r0;
+                    r17 = r17 + -7236;
+                    r23 = r23 + -6264;
+                case 0x1ec4c:
+                    r3 = r2 & 255;
+                    r3 = r17 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 64;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ed0c;
+                        continue;
+                    }
+                case 0x1ec68:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ef3c;
+                        run_1ee00(); return;
+                    }
+                case 0x1ec84:
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = r3 + 1;
+                    r3 = r5 + r3;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r6;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ed6c;
+                        continue;
+                    }
+                    r2 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1eccc:
+                    r3 = r0 + 10;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ec4c;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    r3 = r2 & 255;
+                    r3 = r17 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 64;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ec68;
+                        continue;
+                    }
+                case 0x1ed0c:
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ed24;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6844;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ed24;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1ed24:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ed34;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1ed34:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1ed6c:
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r30 = r0 + r0;
+                    r19 = r0 + -1;
+                    r20 = r0 + 13;
+                    r18 = r0 + 10;
+                case 0x1ed80:
+                    r4 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f100;
+                        run_1f000(); return;
+                    }
+                case 0x1ed8c:
+                    r5 = r5 << 2;
+                    r5 = r23 + r5;
+                    r4 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r4;
+                    return;
+                case 0x1eda4:
+                    if(r30 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ee30;
+                        run_1ee00(); return;
+                    }
+                case 0x1edac:
+                    if(r30 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ee30;
+                        run_1ee00(); return;
+                    }
+                    if(r30 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ee30;
+                        run_1ee00(); return;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1edc4:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ef58;
+                        run_1ee00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1ee00:
+                    pc=0x1ee00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1ee00() throws ExecutionException { /* 0x1ee00 - 0x1f000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1ee00:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1eda4;
+                        run_1ec00(); return;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ee28;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1ee28:
+                    if(r30 != r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1edac;
+                        run_1ec00(); return;
+                    }
+                case 0x1ee30:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r4;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1ed8c;
+                    run_1ec00(); return;
+                case 0x1ee48:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f1e8;
+                        run_1f000(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1ee84:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1eeac;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1eeac;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1eeac:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1eeb0:
+                    r4 = r0 + -1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f190;
+                        run_1f000(); return;
+                    }
+                    r4 = r30 & 255;
+                    r4 = r17 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ef28;
+                        continue;
+                    }
+                    r4 = r0 + 32;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f148;
+                        run_1f000(); return;
+                    }
+                    r4 = r30 < 33 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f124;
+                        run_1f000(); return;
+                    }
+                    r4 = r0 + 59;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f160;
+                        run_1f000(); return;
+                    }
+                    r4 = r0 + 125;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f1d0;
+                        run_1f000(); return;
+                    }
+                    r3 = r0 + 58;
+                    if(r30 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f1c0;
+                        run_1f000(); return;
+                    }
+                case 0x1ef18:
+                    r2 = 7 << 16;
+                    r4 = r2 + -6740;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ef28;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1ef28:
+                    r2 = r30 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1ef3c:
+                    /* Next insn is delay slot */ 
+                    r31=0x1ef44;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1ef44:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1ec84;
+                    run_1ec00(); return;
+                case 0x1ef58:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1ef68;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1ef68:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1ee00;
+                    continue;
+                case 0x1ef74:
+                    r2 = r0 + 125;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1ef88:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f204;
+                        run_1f200(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1efc4:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1efec;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1efec;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1efec:
+                    if(r30 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ee30;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                case 0x1f000:
+                    pc=0x1f000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1f000() throws ExecutionException { /* 0x1f000 - 0x1f200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1f000:
+                    /* Next insn is delay slot */ 
+                    pc=0x1ed8c;
+                    run_1ec00(); return;
+                case 0x1f008:
+                    r2 = r0 + 5;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 10;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f020:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r21 = r0 + 9;
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r22 = r0 + 32;
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f0bc;
+                        continue;
+                    }
+                case 0x1f040:
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1f05c:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f084;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f084;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1f084:
+                    if(r30 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f094;
+                        continue;
+                    }
+                    if(r30 != r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ee30;
+                        run_1ee00(); return;
+                    }
+                case 0x1f094:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f040;
+                        continue;
+                    }
+                case 0x1f0bc:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1f0cc;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1f0cc:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f05c;
+                    continue;
+                case 0x1f0d8:
+                    r2 = r0 + 13;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f0ec:
+                    r2 = r0 + 10;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f100:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6700;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f110;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1f110:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1ed80;
+                    run_1ec00(); return;
+                case 0x1f124:
+                    r4 = r0 + 10;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f178;
+                        continue;
+                    }
+                    r4 = r0 + 13;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f1a8;
+                        continue;
+                    }
+                    r4 = r0 + 9;
+                    if(r30 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ef18;
+                        run_1ee00(); return;
+                    }
+                case 0x1f148:
+                    r2 = r0 + 2;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 32;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f160:
+                    r2 = r0 + 6;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f178:
+                    r2 = r0 + 3;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f190:
+                    r2 = r0 + 8;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f1a8:
+                    r2 = r0 + 4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f1c0:
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f1d0:
+                    r2 = r0 + 7;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1eccc;
+                    run_1ec00(); return;
+                case 0x1f1e8:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1f1f8;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1f1f8:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1ee84;
+                    run_1ee00(); return;
+                case 0x1f200:
+                    pc=0x1f200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1f200() throws ExecutionException { /* 0x1f200 - 0x1f400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1f200:
+                case 0x1f204:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1f214;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1f214:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1efc4;
+                    run_1ee00(); return;
+                case 0x1f400:
+                    pc=0x1f400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1f400() throws ExecutionException { /* 0x1f400 - 0x1f600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1f400:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -56;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r23;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    r17 = 7 << 16;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    r23 = 7 << 16;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r16 = r0 + r0;
+                    r17 = r17 + -7236;
+                    r23 = r23 + -6228;
+                case 0x1f44c:
+                    r3 = r2 & 255;
+                    r3 = r17 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 64;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f50c;
+                        continue;
+                    }
+                case 0x1f468:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f750;
+                        run_1f600(); return;
+                    }
+                case 0x1f484:
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = r3 + 1;
+                    r3 = r5 + r3;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r6;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f580;
+                        continue;
+                    }
+                    r2 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x1f4cc:
+                    r3 = r0 + 10;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f44c;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    r3 = r2 & 255;
+                    r3 = r17 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 64;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f468;
+                        continue;
+                    }
+                case 0x1f50c:
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f524;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6844;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f524;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1f524:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f534;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1f534:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f548;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x1f548:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1f580:
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r30 = r0 + r0;
+                    r19 = r0 + -1;
+                    r20 = r0 + 13;
+                    r18 = r0 + 10;
+                case 0x1f594:
+                    r4 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f914;
+                        run_1f800(); return;
+                    }
+                case 0x1f5a0:
+                    r5 = r5 << 2;
+                    r5 = r23 + r5;
+                    r4 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r4;
+                    return;
+                case 0x1f5b8:
+                    if(r30 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f644;
+                        run_1f600(); return;
+                    }
+                case 0x1f5c0:
+                    if(r30 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f644;
+                        run_1f600(); return;
+                    }
+                    if(r30 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f644;
+                        run_1f600(); return;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1f5d8:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f76c;
+                        run_1f600(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                case 0x1f600:
+                    pc=0x1f600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1f600() throws ExecutionException { /* 0x1f600 - 0x1f800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1f600:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1f614:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f5b8;
+                        run_1f400(); return;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f63c;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1f63c:
+                    if(r30 != r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f5c0;
+                        run_1f400(); return;
+                    }
+                case 0x1f644:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r4;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f5a0;
+                    run_1f400(); return;
+                case 0x1f65c:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f9fc;
+                        run_1f800(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1f698:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f6c0;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f6c0;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1f6c0:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                case 0x1f6c4:
+                    r4 = r0 + -1;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f9a4;
+                        run_1f800(); return;
+                    }
+                    r4 = r30 & 255;
+                    r4 = r17 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f73c;
+                        continue;
+                    }
+                    r4 = r0 + 32;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f95c;
+                        run_1f800(); return;
+                    }
+                    r4 = r30 < 33 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f938;
+                        run_1f800(); return;
+                    }
+                    r4 = r0 + 59;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f974;
+                        run_1f800(); return;
+                    }
+                    r4 = r0 + 125;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f9e4;
+                        run_1f800(); return;
+                    }
+                    r3 = r0 + 58;
+                    if(r30 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f9d4;
+                        run_1f800(); return;
+                    }
+                case 0x1f72c:
+                    r2 = 7 << 16;
+                    r4 = r2 + -6740;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f73c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1f73c:
+                    r2 = r30 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f750:
+                    /* Next insn is delay slot */ 
+                    r31=0x1f758;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1f758:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1f484;
+                    run_1f400(); return;
+                case 0x1f76c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1f77c;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1f77c:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f614;
+                    continue;
+                case 0x1f788:
+                    r2 = r0 + 125;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f79c:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fa18;
+                        run_1fa00(); return;
+                    }
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1f7d8:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f800;
+                        run_1f800(); return;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f800;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1f800:
+                    pc=0x1f800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1f800() throws ExecutionException { /* 0x1f800 - 0x1fa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1f800:
+                    if(r30 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f644;
+                        run_1f600(); return;
+                    }
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f5a0;
+                    run_1f400(); return;
+                case 0x1f81c:
+                    r2 = r0 + 5;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 10;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f834:
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r21 = r0 + 9;
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r22 = r0 + 32;
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f8d0;
+                        continue;
+                    }
+                case 0x1f854:
+                    r3 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r30 = tmp;
+                case 0x1f870:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f898;
+                        continue;
+                    }
+                    r4 = r30 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f898;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1f898:
+                    if(r30 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f8a8;
+                        continue;
+                    }
+                    if(r30 != r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f644;
+                        run_1f600(); return;
+                    }
+                case 0x1f8a8:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f854;
+                        continue;
+                    }
+                case 0x1f8d0:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1f8e0;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1f8e0:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f870;
+                    continue;
+                case 0x1f8ec:
+                    r2 = r0 + 13;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f900:
+                    r2 = r0 + 10;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f914:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6700;
+                    /* Next insn is delay slot */ 
+                    r31=0x1f924;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x1f924:
+                    r3 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1f594;
+                    run_1f400(); return;
+                case 0x1f938:
+                    r4 = r0 + 10;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f98c;
+                        continue;
+                    }
+                    r4 = r0 + 13;
+                    if(r30 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f9bc;
+                        continue;
+                    }
+                    r4 = r0 + 9;
+                    if(r30 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1f72c;
+                        run_1f600(); return;
+                    }
+                case 0x1f95c:
+                    r2 = r0 + 2;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 32;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f974:
+                    r2 = r0 + 6;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f98c:
+                    r2 = r0 + 3;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f9a4:
+                    r2 = r0 + 8;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f9bc:
+                    r2 = r0 + 4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f9d4:
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f9e4:
+                    r2 = r0 + 7;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f4cc;
+                    run_1f400(); return;
+                case 0x1f9fc:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                case 0x1fa00:
+                    pc=0x1fa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1fa00() throws ExecutionException { /* 0x1fa00 - 0x1fc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1fa00:
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1fa0c;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1fa0c:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f698;
+                    run_1f600(); return;
+                case 0x1fa18:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1fa28;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1fa28:
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1f7d8;
+                    run_1f600(); return;
+                case 0x1fc00:
+                    pc=0x1fc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1fc00() throws ExecutionException { /* 0x1fc00 - 0x1fe00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1fc00:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -56;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r20;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fef0;
+                        run_1fe00(); return;
+                    }
+                case 0x1fc38:
+                    r3 = r0 + 60;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fe9c;
+                        run_1fe00(); return;
+                    }
+                    r3 = r0 + 34;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fd44;
+                        continue;
+                    }
+                    r16 = r0 + 34;
+                case 0x1fc54:
+                    /* Next insn is delay slot */ 
+                    r31=0x1fc5c;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x1fc5c:
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ff28;
+                        run_1fe00(); return;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r18 = 7 << 16;
+                    r17 = r0 + 10;
+                    r19 = r0 + 13;
+                    r20 = r0 + -1;
+                    r18 = r18 + -6680;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fd18;
+                        continue;
+                    }
+                case 0x1fc84:
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fecc;
+                        run_1fe00(); return;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fdf8;
+                        continue;
+                    }
+                    r5 = r4 + r0;
+                case 0x1fcac:
+                    r4 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r6 = r3 + 1;
+                    r3 = r4 + r3;
+                    writePages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff] = r6;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fd60;
+                        continue;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r4 = r3 + 1;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fc84;
+                        continue;
+                    }
+                case 0x1fcfc:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fd08;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1fd08:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fc84;
+                        continue;
+                    }
+                case 0x1fd18:
+                    r2 = r0 + 1;
+                case 0x1fd1c:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r21 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r20 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x1fd44:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6532;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fd54;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1fd54:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd1c;
+                    continue;
+                case 0x1fd60:
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r3;
+                    if(r3 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fe80;
+                        run_1fe00(); return;
+                    }
+                    r3 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r21 = tmp;
+                case 0x1fd9c:
+                    r2 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fdc4;
+                        continue;
+                    }
+                    r4 = r21 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fdc4;
+                    pc=0x1ba00;
+                    run_1ba00(); return;
+                case 0x1fdc4:
+                    if(r21 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fe5c;
+                        run_1fe00(); return;
+                    }
+                    if(r21 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fe38;
+                        run_1fe00(); return;
+                    }
+                    if(r21 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fe14;
+                        run_1fe00(); return;
+                    }
+                    r2 = r21 << 24;
+                    r2 = r2 >> 24;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1fc84;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x1fcfc;
+                    continue;
+                case 0x1fdf8:
+                    /* Next insn is delay slot */ 
+                    r31=0x1fe00;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x1fe00:
+                    pc=0x1fe00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_1fe00() throws ExecutionException { /* 0x1fe00 - 0x20000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x1fe00:
+                    r5 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1fcac;
+                    run_1fc00(); return;
+                case 0x1fe14:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 8;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r18 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fe30;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1fe30:
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd08;
+                    run_1fc00(); return;
+                case 0x1fe38:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 4;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r18 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fe54;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1fe54:
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd08;
+                    run_1fc00(); return;
+                case 0x1fe5c:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = r0 + 3;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r4 = r18 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fe78;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1fe78:
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd08;
+                    run_1fc00(); return;
+                case 0x1fe80:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x1fe90;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x1fe90:
+                    r21 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd9c;
+                    run_1fc00(); return;
+                case 0x1fe9c:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ff0c;
+                        continue;
+                    }
+                    r5 = readPages[(r28+-30676)>>>12][((r28+-30676)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x1ff44;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r16 = r0 + 62;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fec4;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x1fec4:
+                    /* Next insn is delay slot */ 
+                    pc=0x1fc54;
+                    run_1fc00(); return;
+                case 0x1fecc:
+                    /* Next insn is delay slot */ 
+                    r31=0x1fed4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1fed4:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fee4;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x1fee4:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd1c;
+                    run_1fc00(); return;
+                case 0x1fef0:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    r31=0x1fefc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x1fefc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x1fc38;
+                    run_1fc00(); return;
+                case 0x1ff0c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6608;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ff1c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1ff1c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd1c;
+                    run_1fc00(); return;
+                case 0x1ff28:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6492;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ff38;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1ff38:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd1c;
+                    run_1fc00(); return;
+                case 0x1ff44:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6572;
+                    /* Next insn is delay slot */ 
+                    r31=0x1ff54;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x1ff54:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x1fd1c;
+                    run_1fc00(); return;
+                case 0x20000:
+                    pc=0x20000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_20000() throws ExecutionException { /* 0x20000 - 0x20200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x20000:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -24;
+                    r3 = r0 + 32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20060;
+                        continue;
+                    }
+                case 0x20018:
+                    r3 = r0 + 44;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20038;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                case 0x20028:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x20038:
+                    /* Next insn is delay slot */ 
+                    r31=0x20040;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x20040:
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20074;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x20060:
+                    /* Next insn is delay slot */ 
+                    r31=0x20068;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x20068:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x20018;
+                    continue;
+                case 0x20074:
+                    /* Next insn is delay slot */ 
+                    r31=0x2007c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2007c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x20028;
+                    continue;
+                case 0x20200:
+                    pc=0x20200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_20200() throws ExecutionException { /* 0x20200 - 0x20400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x20200:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -24;
+                    r3 = r0 + 43;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20264;
+                        continue;
+                    }
+                    r16 = r0 + r0;
+                case 0x20220:
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20244;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x20244:
+                    /* Next insn is delay slot */ 
+                    r31=0x2024c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2024c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x20264:
+                    /* Next insn is delay slot */ 
+                    r31=0x2026c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2026c:
+                    r3 = r0 + 49;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x202b0;
+                        continue;
+                    }
+                    r3 = r0 + 50;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x202c8;
+                        continue;
+                    }
+                    r3 = r0 + 51;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x202d4;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6472;
+                    /* Next insn is delay slot */ 
+                    r31=0x202a0;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x202a0:
+                    r16 = r0 + r0;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x20220;
+                    continue;
+                case 0x202b0:
+                    r16 = r0 + 1;
+                case 0x202b4:
+                    /* Next insn is delay slot */ 
+                    r31=0x202bc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x202bc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x20220;
+                    continue;
+                case 0x202c8:
+                    r16 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x202b4;
+                    continue;
+                case 0x202d4:
+                    r16 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x202b4;
+                    continue;
+                case 0x20400:
+                    pc=0x20400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_20400() throws ExecutionException { /* 0x20400 - 0x20600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x20400:
+                    r29 = r29 + -24;
+                    r4 = r0 + 128;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x20414;
+                    pc=0x17600;
+                    run_17600(); return;
+                case 0x20414:
+                    r4 = r0 + 128;
+                    writePages[(r28+-30720)>>>12][((r28+-30720)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x20424;
+                    pc=0x17600;
+                    run_17600(); return;
+                case 0x20424:
+                    writePages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-32236)>>>12][((r28+-32236)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30728)>>>12][((r28+-30728)>>>2)&0x3ff];
+                    r3 = r2 << 1;
+                    r5 = r2 << 4;
+                    r2 = r2 << 6;
+                    r5 = r2 - r5;
+                    writePages[(r28+-32236)>>>12][((r28+-32236)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x2044c;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x2044c:
+                    writePages[(r28+-30728)>>>12][((r28+-30728)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20468;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x20468:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -6876;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x20600:
+                    pc=0x20600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_20600() throws ExecutionException { /* 0x20600 - 0x20800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x20600:
+                    r29 = r29 + -48;
+                    r4 = r29 + 16;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x20628;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x20628:
+                    r2 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30720)>>>12][((r28+-30720)>>>2)&0x3ff];
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20998;
+                        run_20800(); return;
+                    }
+                case 0x2064c:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x20660;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x20660:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x20674;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x20674:
+                    r4 = readPages[(r28+-30720)>>>12][((r28+-30720)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20684;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20684:
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r5 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x20694;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20694:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x209b0;
+                        run_20800(); return;
+                    }
+                case 0x206a4:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = r0 + 123;
+                    r19 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x207d0;
+                        continue;
+                    }
+                    r17 = r0 + 126;
+                    r16 = r0 + 46;
+                    r18 = r0 + 44;
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    if(r2 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20748;
+                        continue;
+                    }
+                case 0x206d4:
+                    r5 = r0 + 118;
+                    /* Next insn is delay slot */ 
+                    r31=0x206e0;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x206e0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2077c;
+                        continue;
+                    }
+                case 0x206f0:
+                    /* Next insn is delay slot */ 
+                    r31=0x206f8;
+                    pc=0x1dc00;
+                    run_1dc00(); return;
+                case 0x206f8:
+                    /* Next insn is delay slot */ 
+                    r31=0x20700;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x20700:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x207ac;
+                        continue;
+                    }
+                case 0x20708:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2097c;
+                        run_20800(); return;
+                    }
+                case 0x20724:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    if(r2 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x206d4;
+                        continue;
+                    }
+                case 0x20748:
+                    r5 = r0 + 86;
+                    /* Next insn is delay slot */ 
+                    r31=0x20754;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20754:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + 126;
+                    /* Next insn is delay slot */ 
+                    r31=0x20764;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20764:
+                    /* Next insn is delay slot */ 
+                    r31=0x2076c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2076c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x206f0;
+                        continue;
+                    }
+                case 0x2077c:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + 46;
+                    /* Next insn is delay slot */ 
+                    r31=0x2078c;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x2078c:
+                    /* Next insn is delay slot */ 
+                    r31=0x20794;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x20794:
+                    /* Next insn is delay slot */ 
+                    r31=0x2079c;
+                    pc=0x1dc00;
+                    run_1dc00(); return;
+                case 0x2079c:
+                    /* Next insn is delay slot */ 
+                    r31=0x207a4;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x207a4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20708;
+                        continue;
+                    }
+                case 0x207ac:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 123;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x207cc;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6860;
+                    /* Next insn is delay slot */ 
+                    r31=0x207cc;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x207cc:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                case 0x207d0:
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x207dc;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x207dc:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x207e8;
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x207e8:
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x207fc;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x207fc:
+                    r2 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                case 0x20800:
+                    pc=0x20800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_20800() throws ExecutionException { /* 0x20800 - 0x20a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x20800:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20814;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x20814:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20824;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20824:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + 15856;
+                    r6 = r19 + r0;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x20840;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x20840:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x208a0;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r16 = 7 << 16;
+                    r17 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r4 = r16 + -6052;
+                    /* Next insn is delay slot */ 
+                    r31=0x20860;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x20860:
+                    r3 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r16 + -6052;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r3 = r3 + -6192;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r3 = 7 << 16;
+                    r3 = r3 + -6180;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x208a0;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x208a0:
+                    r4 = r0 + 20;
+                    /* Next insn is delay slot */ 
+                    r31=0x208ac;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x208ac:
+                    r16 = r2 + r0;
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r18 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x208d0;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x208d0:
+                    r17 = r2 + 1;
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x208e0;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x208e0:
+                    r4 = r2 + r0;
+                    r5 = r18 + r0;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x208f4;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x208f4:
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30720)>>>12][((r28+-30720)>>>2)&0x3ff];
+                    r18 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20914;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x20914:
+                    r17 = r2 + 1;
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20924;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x20924:
+                    r4 = r2 + r0;
+                    r5 = r18 + r0;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20938;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x20938:
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r20;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x2094c;
+                    pc=0x1d400;
+                    run_1d400(); return;
+                case 0x2094c:
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r16;
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2097c:
+                    /* Next insn is delay slot */ 
+                    r31=0x20984;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x20984:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x20724;
+                    run_20600(); return;
+                case 0x20998:
+                    r5 = r0 + 46;
+                    /* Next insn is delay slot */ 
+                    r31=0x209a4;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x209a4:
+                    r4 = readPages[(r28+-30720)>>>12][((r28+-30720)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x2064c;
+                    run_20600(); return;
+                case 0x209b0:
+                    /* Next insn is delay slot */ 
+                    r31=0x209b8;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x209b8:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x206a4;
+                    run_20600(); return;
+                case 0x20a00:
+                    pc=0x20a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_20a00() throws ExecutionException { /* 0x20a00 - 0x20c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x20a00:
+                    r2 = readPages[(r28+-32760)>>>12][((r28+-32760)>>>2)&0x3ff];
+                    r29 = r29 + -96;
+                    r2 = r2 + -1;
+                    writePages[(r28+-32760)>>>12][((r28+-32760)>>>2)&0x3ff] = r2;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r31;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r22;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r21;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r20;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r19;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r18;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r17;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r16;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20e64;
+                        run_20e00(); return;
+                    }
+                case 0x20a38:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x20a44;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x20a44:
+                    r2 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30720)>>>12][((r28+-30720)>>>2)&0x3ff];
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20e24;
+                        run_20e00(); return;
+                    }
+                case 0x20a68:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x20a7c;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x20a7c:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x20a90;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x20a90:
+                    r4 = readPages[(r28+-30720)>>>12][((r28+-30720)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20aa0;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20aa0:
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r5 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x20ab0;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20ab0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20e50;
+                        run_20e00(); return;
+                    }
+                case 0x20ac0:
+                    r19 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20bdc;
+                        continue;
+                    }
+                    r20 = 7 << 16;
+                    r17 = r0 + r0;
+                    r16 = r0 + r0;
+                    r20 = r20 + -6876;
+                    r18 = r0 + 126;
+                    /* Next insn is delay slot */ 
+                    pc=0x20b2c;
+                    continue;
+                case 0x20ae8:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    if(r2 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20b88;
+                        continue;
+                    }
+                case 0x20af8:
+                    r5 = r0 + 118;
+                    /* Next insn is delay slot */ 
+                    r31=0x20b04;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20b04:
+                    r4 = readPages[(r28+-30728)>>>12][((r28+-30728)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    r4 = r4 + r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x20b18;
+                    pc=0x16400;
+                    run_16400(); return;
+                case 0x20b18:
+                    /* Next insn is delay slot */ 
+                    r31=0x20b20;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x20b20:
+                    r17 = r17 + 24;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20bdc;
+                        continue;
+                    }
+                case 0x20b2c:
+                    r2 = readPages[(r28+-32236)>>>12][((r28+-32236)>>>2)&0x3ff];
+                    r3 = r16 < r2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20ae8;
+                        continue;
+                    }
+                    r3 = r2 << 1;
+                    r5 = r2 << 4;
+                    r4 = readPages[(r28+-30728)>>>12][((r28+-30728)>>>2)&0x3ff];
+                    r2 = r2 << 6;
+                    r5 = r2 - r5;
+                    writePages[(r28+-32236)>>>12][((r28+-32236)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x20b60;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x20b60:
+                    writePages[(r28+-30728)>>>12][((r28+-30728)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20ae8;
+                        continue;
+                    }
+                    r4 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20b78;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x20b78:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    if(r2 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20af8;
+                        continue;
+                    }
+                case 0x20b88:
+                    r5 = r0 + 86;
+                    /* Next insn is delay slot */ 
+                    r31=0x20b94;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20b94:
+                    /* Next insn is delay slot */ 
+                    r31=0x20b9c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x20b9c:
+                    r4 = r29 + 52;
+                    /* Next insn is delay slot */ 
+                    r31=0x20ba8;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x20ba8:
+                    r21 = readPages[(r28+-30728)>>>12][((r28+-30728)>>>2)&0x3ff];
+                    r4 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    r21 = r21 + r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x20bc0;
+                    pc=0x2f400;
+                    run_2f400(); return;
+                case 0x20bc0:
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x20bcc;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x20bcc:
+                    r16 = r16 + 1;
+                    r17 = r17 + 24;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20b2c;
+                        continue;
+                    }
+                case 0x20bdc:
+                    r4 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20bec;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20bec:
+                    r2 = readPages[(r28+-30724)>>>12][((r28+-30724)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20c04;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x20c00:
+                    pc=0x20c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_20c00() throws ExecutionException { /* 0x20c00 - 0x20e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x20c00:
+                case 0x20c04:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20c14;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20c14:
+                    r5 = 7 << 16;
+                    r4 = r29 + 60;
+                    r5 = r5 + 15856;
+                    r6 = r19 + r0;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20c30;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x20c30:
+                    r2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20e7c;
+                        run_20e00(); return;
+                    }
+                    r17 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r2 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r4 = r29 + 36;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    r5 = r5 + -6084;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r17+12)>>>12][((r17+12)>>>2)&0x3ff];
+                    r7 = r0 + r0;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r6 = readPages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff];
+                    r2 = r29 + 16;
+                    r20 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r19 = tmp;
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r2;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r0;
+                    r21 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x20c98;
+                    pc=0x2e400;
+                    run_2e400(); return;
+                case 0x20c98:
+                    /* Next insn is delay slot */ 
+                    r31=0x20ca0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x20ca0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20d94;
+                        continue;
+                    }
+                    r18 = 7 << 16;
+                    r22 = 7 << 16;
+                    r16 = r0 + r0;
+                    r18 = r18 + 16944;
+                    r22 = r22 + -6076;
+                    /* Next insn is delay slot */ 
+                    pc=0x20d18;
+                    continue;
+                case 0x20ccc:
+                    r4 = r29 + 52;
+                    /* Next insn is delay slot */ 
+                    r31=0x20cd8;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x20cd8:
+                    r4 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20ce8;
+                    pc=0x2f400;
+                    run_2f400(); return;
+                case 0x20ce8:
+                    r5 = readPages[(r28+-30728)>>>12][((r28+-30728)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    r5 = r5 + r16;
+                    r6 = r0 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x20d00;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x20d00:
+                    /* Next insn is delay slot */ 
+                    r31=0x20d08;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x20d08:
+                    r16 = r16 + 24;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20d94;
+                        continue;
+                    }
+                case 0x20d14:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                case 0x20d18:
+                    r2 = r0 + 126;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20ccc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x20d2c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x20d2c:
+                    r4 = r29 + 52;
+                    /* Next insn is delay slot */ 
+                    r31=0x20d38;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x20d38:
+                    r6 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r4 = r29 + 56;
+                    r5 = r18 + r0;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x20d50;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x20d50:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20d68;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20e3c;
+                        run_20e00(); return;
+                    }
+                case 0x20d68:
+                    r2 = readPages[(r28+-30728)>>>12][((r28+-30728)>>>2)&0x3ff];
+                    r2 = r2 + r16;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r16 = r16 + 24;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x20d8c;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x20d8c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20d14;
+                        continue;
+                    }
+                case 0x20d94:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r3 = readPages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff];
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x20dac;
+                    pc=0x1a400;
+                    run_1a400(); return;
+                case 0x20dac:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r2 = r0 + 125;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x20dcc;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -7708;
+                    /* Next insn is delay slot */ 
+                    r31=0x20dcc;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x20dcc:
+                    r4 = r29 + 36;
+                    /* Next insn is delay slot */ 
+                    r31=0x20dd8;
+                    pc=0x2e600;
+                    run_2e600(); return;
+                case 0x20dd8:
+                    writePages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff] = r21;
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r20;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r19&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x20dec;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x20dec:
+                    r2 = readPages[(r28+-32760)>>>12][((r28+-32760)>>>2)&0x3ff];
+                    r31 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r22 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r21 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                case 0x20e00:
+                    pc=0x20e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_20e00() throws ExecutionException { /* 0x20e00 - 0x21000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x20e00:
+                    r20 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r19 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r18 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r17 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r16 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    writePages[(r28+-32760)>>>12][((r28+-32760)>>>2)&0x3ff] = r2;
+                    r29 = r29 + 96;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x20e24:
+                    r5 = r0 + 46;
+                    /* Next insn is delay slot */ 
+                    r31=0x20e30;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x20e30:
+                    r4 = readPages[(r28+-30720)>>>12][((r28+-30720)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x20a68;
+                    run_20a00(); return;
+                case 0x20e3c:
+                    r4 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x20e48;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x20e48:
+                    /* Next insn is delay slot */ 
+                    pc=0x20d68;
+                    run_20c00(); return;
+                case 0x20e50:
+                    /* Next insn is delay slot */ 
+                    r31=0x20e58;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x20e58:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x20ac0;
+                    run_20a00(); return;
+                case 0x20e64:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6168;
+                    /* Next insn is delay slot */ 
+                    r31=0x20e74;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x20e74:
+                    /* Next insn is delay slot */ 
+                    pc=0x20a38;
+                    run_20a00(); return;
+                case 0x20e7c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6124;
+                    /* Next insn is delay slot */ 
+                    r31=0x20e8c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x20e8c:
+                    /* Next insn is delay slot */ 
+                    r31=0x20e94;
+                    pc=0x1c800;
+                    run_1c800(); return;
+                case 0x20e94:
+                    /* Next insn is delay slot */ 
+                    pc=0x20dec;
+                    run_20c00(); return;
+                case 0x21000:
+                    pc=0x21000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_21000() throws ExecutionException { /* 0x21000 - 0x21200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x21000:
+                    r29 = r29 + -32;
+                    r3 = r6 & 255;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r16 = r5 + r0;
+                    r5 = r6 & 65280;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r2 = ((r0 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21028;
+                        continue;
+                    }
+                    r2 = r2 | 2;
+                case 0x21028:
+                    r5 = 255 << 16;
+                    r5 = r6 & r5;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21094;
+                        continue;
+                    }
+                    r2 = r2 | 4;
+                case 0x2103c:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x210b8;
+                        continue;
+                    }
+                    r2 = r2 & r4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21290;
+                        run_21200(); return;
+                    }
+                case 0x21050:
+                    r2 = r0 + 2;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x211b0;
+                        continue;
+                    }
+                    r2 = r0 + 4;
+                    if(r4 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21220;
+                        run_21200(); return;
+                    }
+                case 0x21068:
+                    r4 = r6 >>> 16;
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r4 & 255;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2107c;
+                    return;
+                case 0x2107c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x26200;
+                    run_26200(); return;
+                case 0x21094:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2103c;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -3048;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x210b8:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r5 = r4 & 7;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x211dc;
+                        continue;
+                    }
+                    r5 = r2 + -1;
+                    r5 = (r5&0xffffffffL) < (2&0xffffffffL) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x212d0;
+                        run_21200(); return;
+                    }
+                    r5 = r0 + 4;
+                    if(r2 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21068;
+                        continue;
+                    }
+                    r5 = r4 & 32;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21240;
+                        run_21200(); return;
+                    }
+                    r5 = r2 & 1;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2110c;
+                        continue;
+                    }
+                    r5 = r4 & 8;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21268;
+                        run_21200(); return;
+                    }
+                case 0x2110c:
+                    r5 = r2 & 2;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21170;
+                        continue;
+                    }
+                    r2 = r2 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21268;
+                        run_21200(); return;
+                    }
+                    r4 = r4 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21068;
+                        continue;
+                    }
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r0 | 32768;
+                    r3 = r3 + r2;
+                    r2 = 1 << 16;
+                    r2 = r2 | 32768;
+                    r2 = ((r3 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21068;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -3084;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x21164;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x21164:
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x21068;
+                    continue;
+                case 0x21170:
+                    r4 = r4 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x211b0;
+                        continue;
+                    }
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 + 128;
+                    r2 = (r2&0xffffffffL) < (384&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x211b0;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -3084;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x211a8;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x211a8:
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x211b0:
+                    r4 = r6 >>> 8;
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r4 & 255;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x211c4;
+                    return;
+                case 0x211c4:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x26000;
+                    run_26000(); return;
+                case 0x211dc:
+                    r4 = r2 & r4;
+                    r5 = r4 & 1;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21268;
+                        run_21200(); return;
+                    }
+                    r4 = r4 & 2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x211b0;
+                        continue;
+                    }
+                case 0x211f8:
+                    r2 = r2 & 4;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21068;
+                        continue;
+                    }
+                case 0x21200:
+                    pc=0x21200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_21200() throws ExecutionException { /* 0x21200 - 0x21400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x21200:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -6936;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x21220:
+                    r2 = r0 + 1;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21268;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x21240:
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    if(r4 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x212dc;
+                        continue;
+                    }
+                    r5 = r2 & 1;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x212ac;
+                        continue;
+                    }
+                    r5 = r4 < 256 ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x212ac;
+                        continue;
+                    }
+                case 0x21268:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x21278;
+                    return;
+                case 0x21278:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x21290:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -6028;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x212ac:
+                    r3 = r2 & 2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x211f8;
+                        run_21000(); return;
+                    }
+                    r3 = 1 << 16;
+                    r4 = r4 < r3 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x211b0;
+                        run_21000(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x211f8;
+                    run_21000(); return;
+                case 0x212d0:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21050;
+                    run_21000(); return;
+                case 0x212dc:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -5984;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x21400:
+                    pc=0x21400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_21400() throws ExecutionException { /* 0x21400 - 0x21600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x21400:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -40;
+                    r3 = r0 + 32;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    r16 = r4 + r0;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2161c;
+                        run_21600(); return;
+                    }
+                case 0x21424:
+                    r3 = r0 + 35;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21544;
+                        continue;
+                    }
+                    r3 = r0 + 91;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x214a8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x21444;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x21444:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21450;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x21450:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2145c;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x2145c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 93;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x216dc;
+                        run_21600(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x2147c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2147c:
+                    r2 = r0 + r0;
+                case 0x21480:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x2148c;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x2148c:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x214a8:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x214b4;
+                    pc=0x16200;
+                    run_16200(); return;
+                case 0x214b4:
+                    r4 = r16 + r0;
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x214c4;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x214c4:
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r3 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21590;
+                        continue;
+                    }
+                    r2 = r0 + 16;
+                    r16 = r0 + r0;
+                case 0x214e0:
+                    r3 = r3 & 128;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x214f0;
+                        continue;
+                    }
+                    r16 = r2 + r0;
+                case 0x214f0:
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21640;
+                        run_21600(); return;
+                    }
+                case 0x214f8:
+                    /* Next insn is delay slot */ 
+                    r31=0x21500;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x21500:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21630;
+                        run_21600(); return;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 + -83;
+                    r2 = r2 & 255;
+                    r3 = (r2&0xffffffffL) < (39&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x215fc;
+                        continue;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -5280;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x21544:
+                    /* Next insn is delay slot */ 
+                    r31=0x2154c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2154c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21558;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x21558:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21564;
+                    pc=0x32000;
+                    run_32000(); return;
+                case 0x21564:
+                    r2 = r0 + 64;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x21574;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x21574:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x21590:
+                    r2 = r0 + 144;
+                    r16 = r0 + 128;
+                    /* Next insn is delay slot */ 
+                    pc=0x214e0;
+                    continue;
+                case 0x215a0:
+                    r17 = r0 + 2;
+                case 0x215a4:
+                    /* Next insn is delay slot */ 
+                    r31=0x215ac;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x215ac:
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21730;
+                        run_21600(); return;
+                    }
+                    r2 = r17 | r16;
+                case 0x215bc:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x215c8;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x215c8:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x215e4:
+                    r17 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x215a4;
+                    continue;
+                case 0x215f0:
+                    r17 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x215a4;
+                    continue;
+                case 0x215fc:
+                    r4 = 7 << 16;
+                case 0x21600:
+                    pc=0x21600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_21600() throws ExecutionException { /* 0x21600 - 0x21800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x21600:
+                    r4 = r4 + -6980;
+                    r17 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21610;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x21610:
+                    r2 = r17 | r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x215bc;
+                    run_21400(); return;
+                case 0x2161c:
+                    /* Next insn is delay slot */ 
+                    r31=0x21624;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x21624:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x21424;
+                    run_21400(); return;
+                case 0x21630:
+                    r17 = r0 + r0;
+                    r2 = r17 | r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x215bc;
+                    run_21400(); return;
+                case 0x21640:
+                    /* Next insn is delay slot */ 
+                    r31=0x21648;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x21648:
+                    r17 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x216b0;
+                        continue;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 + -83;
+                    r2 = r2 & 255;
+                    r3 = (r2&0xffffffffL) < (39&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21798;
+                        continue;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -5124;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x21690:
+                    r17 = r0 + 8;
+                case 0x21694:
+                    /* Next insn is delay slot */ 
+                    r31=0x2169c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2169c:
+                    r3 = r0 + 32;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x216b0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x216b0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x216b0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 41;
+                    r16 = r16 | r17;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x217f4;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x216d4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x216d4:
+                    /* Next insn is delay slot */ 
+                    pc=0x214f8;
+                    run_21400(); return;
+                case 0x216dc:
+                    /* Next insn is delay slot */ 
+                    r31=0x216e4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x216e4:
+                    /* Next insn is delay slot */ 
+                    r31=0x216ec;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x216ec:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x217e8;
+                        continue;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 + -83;
+                    r2 = r2 & 255;
+                    r3 = (r2&0xffffffffL) < (39&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x217b4;
+                        continue;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -4968;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x21730:
+                    /* Next insn is delay slot */ 
+                    r31=0x21738;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x21738:
+                    r2 = r17 | r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x215bc;
+                    run_21400(); return;
+                case 0x21744:
+                    r17 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x21694;
+                    continue;
+                case 0x21750:
+                    r17 = r0 + 12;
+                    /* Next insn is delay slot */ 
+                    pc=0x21694;
+                    continue;
+                case 0x2175c:
+                    r16 = r0 + 34;
+                case 0x21760:
+                    /* Next insn is delay slot */ 
+                    r31=0x21768;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x21768:
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x217d4;
+                        continue;
+                    }
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21480;
+                    run_21400(); return;
+                case 0x21780:
+                    r16 = r0 + 33;
+                    /* Next insn is delay slot */ 
+                    pc=0x21760;
+                    continue;
+                case 0x2178c:
+                    r16 = r0 + 35;
+                    /* Next insn is delay slot */ 
+                    pc=0x21760;
+                    continue;
+                case 0x21798:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x217a8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x217a8:
+                    r17 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x216b0;
+                    continue;
+                case 0x217b4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    r16 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x217c8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x217c8:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21480;
+                    run_21400(); return;
+                case 0x217d4:
+                    /* Next insn is delay slot */ 
+                    r31=0x217dc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x217dc:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21480;
+                    run_21400(); return;
+                case 0x217e8:
+                    r2 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x21480;
+                    run_21400(); return;
+                case 0x217f4:
+                    /* Next insn is delay slot */ 
+                    r31=0x217fc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x217fc:
+                    /* Next insn is delay slot */ 
+                    pc=0x214f8;
+                    run_21400(); return;
+                case 0x21800:
+                    pc=0x21800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_21800() throws ExecutionException { /* 0x21800 - 0x21a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x21800:
+                case 0x21a00:
+                    pc=0x21a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_21a00() throws ExecutionException { /* 0x21a00 - 0x21c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x21a00:
+                    r29 = r29 + -136;
+                    r6 = r5 + r0;
+                    r5 = r29 + 104;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r20;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r19;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r18;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r17;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x21a2c;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x21a2c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21b60;
+                        continue;
+                    }
+                    r16 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r2 = r16 >> 10;
+                    r3 = (r2&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r17 = r16 & 255;
+                    r18 = r16 & 768;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21dc8;
+                        run_21c00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -4812;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x21a74:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x21a80;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x21a80:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x21a8c;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x21a8c:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21e38;
+                        run_21e00(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22058;
+                        run_22000(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r6 = r6 - r2;
+                    r6 = r6 + -2;
+                    r16 = r6 & 65535;
+                    r6 = r6 & 32768;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21aec;
+                        continue;
+                    }
+                    r2 = 65535 << 16;
+                    r16 = r16 + r2;
+                case 0x21aec:
+                    r2 = r16 + 128;
+                    r2 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21b34;
+                        continue;
+                    }
+                    r2 = r16 < -128 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22268;
+                        run_22200(); return;
+                    }
+                    r7 = r0 + -128;
+                    r7 = r7 - r16;
+                case 0x21b10:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5772;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21b28;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x21b28:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x21b34;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x21b34:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x21b44;
+                    return;
+                case 0x21b44:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x21b54;
+                    return;
+                case 0x21b54:
+                    /* Next insn is delay slot */ 
+                    r31=0x21b5c;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x21b5c:
+                    r2 = r0 + 1;
+                case 0x21b60:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r20 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r19 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r18 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r17 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r16 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x21b84:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x21b90;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x21b90:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x21b9c;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x21b9c:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21e8c;
+                        run_21e00(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22084;
+                        run_22000(); return;
+                    }
+                    r16 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r16 = r6 - r16;
+                    r16 = r16 + -3;
+                    r16 = r16 & 65535;
+                case 0x21be8:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x21bf8;
+                    return;
+                case 0x21bf8:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21c04;
+                    pc=0x26000;
+                    run_26000(); return;
+                case 0x21c00:
+                    pc=0x21c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_21c00() throws ExecutionException { /* 0x21c00 - 0x21e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x21c00:
+                case 0x21c04:
+                    /* Next insn is delay slot */ 
+                    r31=0x21c0c;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x21c0c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21b60;
+                    run_21a00(); return;
+                case 0x21c18:
+                    /* Next insn is delay slot */ 
+                    r31=0x21c20;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x21c20:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21c2c;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x21c2c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21e44;
+                        run_21e00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x21c44;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x21c44:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21b60;
+                    run_21a00(); return;
+                case 0x21c50:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x21c5c;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x21c5c:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21c6c;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x21c6c:
+                    r3 = (r2&0xffffffffL) < (65&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2203c;
+                        run_22000(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -4784;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x21c98:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x21ca4;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x21ca4:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21cb4;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x21cb4:
+                    r3 = r0 + 3;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22254;
+                        run_22200(); return;
+                    }
+                    r3 = r2 < 4 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21de8;
+                        continue;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22240;
+                        run_22200(); return;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2203c;
+                        run_22000(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2764;
+                case 0x21cec:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21d04;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x21d04:
+                    r2 = r0 + 1;
+                case 0x21d08:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r20 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r19 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r18 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r17 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r16 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x21d2c:
+                    /* Next insn is delay slot */ 
+                    r31=0x21d34;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x21d34:
+                    r4 = r29 + 16;
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21d44;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x21d44:
+                    r3 = r0 + 16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x220b0;
+                        run_22000(); return;
+                    }
+                    r3 = r2 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21e98;
+                        run_21e00(); return;
+                    }
+                    r3 = r0 + 24;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22134;
+                        run_22000(); return;
+                    }
+                    r3 = r0 + 32;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2203c;
+                        run_22000(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2996;
+                case 0x21d80:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x21d98;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x21d98:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    continue;
+                case 0x21da4:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x21db4;
+                    return;
+                case 0x21db4:
+                    /* Next insn is delay slot */ 
+                    r31=0x21dbc;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x21dbc:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21b60;
+                    run_21a00(); return;
+                case 0x21dc8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5732;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21ddc;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x21ddc:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    continue;
+                case 0x21de8:
+                    r3 = r0 + 64;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22148;
+                        run_22000(); return;
+                    }
+                    r3 = r0 + 128;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2203c;
+                        run_22000(); return;
+                    }
+                case 0x21e00:
+                    pc=0x21e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_21e00() throws ExecutionException { /* 0x21e00 - 0x22000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x21e00:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2920;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2203c;
+                        run_22000(); return;
+                    }
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x21e2c;
+                    return;
+                case 0x21e2c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x21e38:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21b34;
+                    run_21a00(); return;
+                case 0x21e44:
+                    /* Next insn is delay slot */ 
+                    r31=0x21e4c;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x21e4c:
+                    r18 = r2 + r0;
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x21e60;
+                    return;
+                case 0x21e60:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21e6c;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x21e6c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21e78;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x21e78:
+                    /* Next insn is delay slot */ 
+                    r31=0x21e80;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x21e80:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21b60;
+                    run_21a00(); return;
+                case 0x21e8c:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21be8;
+                    run_21a00(); return;
+                case 0x21e98:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2203c;
+                        run_22000(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2948;
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x21ec4;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x21ec4:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x21ed0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2504;
+                case 0x21ed8:
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21ef0;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x21ef0:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x21efc:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2120;
+                case 0x21f08:
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21f20;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x21f20:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x21f2c:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2432;
+                    r17 = r17 + r2;
+                    r2 = 7 << 16;
+                    r3 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r3 & 2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21f98;
+                        continue;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21f98;
+                        continue;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21f90;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r2 = r2 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22294;
+                        run_22200(); return;
+                    }
+                    r20 = readPages[(r2+36)>>>12][((r2+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x21f84:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r2 = r0 + 2;
+                    r20 = r2 - r20;
+                case 0x21f90:
+                    r2 = r6 << 8;
+                    r6 = r2 | r6;
+                case 0x21f98:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x21fa8;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x21fa8:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x21fb4:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2612;
+                    /* Next insn is delay slot */ 
+                    pc=0x21ed8;
+                    continue;
+                case 0x21fc4:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2360;
+                    /* Next insn is delay slot */ 
+                    pc=0x21ed8;
+                    continue;
+                case 0x21fd4:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2540;
+                    /* Next insn is delay slot */ 
+                    pc=0x21ed8;
+                    continue;
+                case 0x21fe4:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2396;
+                    /* Next insn is delay slot */ 
+                    pc=0x21ed8;
+                    continue;
+                case 0x21ff4:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2468;
+                    /* Next insn is delay slot */ 
+                    pc=0x21ed8;
+                    continue;
+                case 0x22000:
+                    pc=0x22000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_22000() throws ExecutionException { /* 0x22000 - 0x22200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x22000:
+                case 0x22004:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2324;
+                    /* Next insn is delay slot */ 
+                    pc=0x21cec;
+                    run_21c00(); return;
+                case 0x22018:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2256;
+                    /* Next insn is delay slot */ 
+                    pc=0x21f08;
+                    run_21e00(); return;
+                case 0x2202c:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2576;
+                    /* Next insn is delay slot */ 
+                    pc=0x21ed8;
+                    run_21e00(); return;
+                case 0x2203c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -3048;
+                    /* Next insn is delay slot */ 
+                    r31=0x2204c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2204c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x22058:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x2206c;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x2206c:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x22078;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x22078:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21b34;
+                    run_21a00(); return;
+                case 0x22084:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x22098;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x22098:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x220a4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x220a4:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21be8;
+                    run_21a00(); return;
+                case 0x220b0:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2964;
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x220d4;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x220d4:
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r0 + 255;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21d04;
+                        run_21c00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21d04;
+                        run_21c00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21d04;
+                        run_21c00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5840;
+                    /* Next insn is delay slot */ 
+                    r31=0x22128;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x22128:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x22134:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2980;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d80;
+                    run_21c00(); return;
+                case 0x22148:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2880;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r17 = 7 << 16;
+                    r3 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r3 & 2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22274;
+                        run_22200(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22274;
+                        run_22200(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x221b0;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r17 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22280;
+                        run_22200(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x221a4:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x221b0:
+                    r16 = r2 << 8;
+                    r16 = r16 | r2;
+                case 0x221b8:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x221cc;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x221cc:
+                    r2 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21d04;
+                        run_21c00(); return;
+                    }
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21d04;
+                        run_21c00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x22200:
+                    pc=0x22200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_22200() throws ExecutionException { /* 0x22200 - 0x22400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x22200:
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21d04;
+                        run_21c00(); return;
+                    }
+                    r2 = r0 + 139;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x222a8;
+                        continue;
+                    }
+                    r2 = r0 + 171;
+                    if(r16 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x21d04;
+                        run_21c00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5888;
+                    /* Next insn is delay slot */ 
+                    r31=0x22234;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x22234:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x22240:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2688;
+                    /* Next insn is delay slot */ 
+                    pc=0x21cec;
+                    run_21c00(); return;
+                case 0x22254:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2840;
+                    /* Next insn is delay slot */ 
+                    pc=0x21cec;
+                    run_21c00(); return;
+                case 0x22268:
+                    r7 = r16 + -127;
+                    /* Next insn is delay slot */ 
+                    pc=0x21b10;
+                    run_21a00(); return;
+                case 0x22274:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x221b8;
+                    run_22000(); return;
+                case 0x22280:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x221a4;
+                    run_22000(); return;
+                case 0x22294:
+                    r20 = readPages[(r2+40)>>>12][((r2+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x21f84;
+                    run_21e00(); return;
+                case 0x222a8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5936;
+                    /* Next insn is delay slot */ 
+                    r31=0x222b8;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x222b8:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x21d08;
+                    run_21c00(); return;
+                case 0x22400:
+                    pc=0x22400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_22400() throws ExecutionException { /* 0x22400 - 0x22600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x22400:
+                    r29 = r29 + -24;
+                    r4 = r0 + 8;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x22414;
+                    pc=0x17600;
+                    run_17600(); return;
+                case 0x22414:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30692;
+                    r5 = r5 + 7760;
+                    writePages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x2242c;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x2242c:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30696;
+                    r5 = r5 + 7340;
+                    /* Next insn is delay slot */ 
+                    r31=0x22440;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x22440:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30700;
+                    r5 = r5 + 7320;
+                    /* Next insn is delay slot */ 
+                    r31=0x22454;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x22454:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30704;
+                    r5 = r5 + 7260;
+                    /* Next insn is delay slot */ 
+                    r31=0x22468;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x22468:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30708;
+                    r5 = r5 + 6860;
+                    /* Next insn is delay slot */ 
+                    r31=0x2247c;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x2247c:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30712;
+                    r5 = r5 + 6820;
+                    /* Next insn is delay slot */ 
+                    r31=0x22490;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x22490:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = r28 + -30716;
+                    r5 = r5 + 6100;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x22600:
+                    pc=0x22600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_22600() throws ExecutionException { /* 0x22600 - 0x22800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x22600:
+                    r2 = r0 + 3;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22618;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x22618:
+                    r4 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -136;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r20;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r19;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r18;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r17;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x22644;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x22644:
+                    r4 = readPages[(r28+-30692)>>>12][((r28+-30692)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = r29 + 104;
+                    /* Next insn is delay slot */ 
+                    r31=0x22658;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x22658:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2278c;
+                        continue;
+                    }
+                    r16 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r2 = r16 >> 10;
+                    r3 = (r2&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r17 = r16 & 255;
+                    r18 = r16 & 768;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22b5c;
+                        run_22a00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -4524;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x226a0:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x226ac;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x226ac:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x226b8;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x226b8:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22c14;
+                        run_22c00(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22c64;
+                        run_22c00(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = r6 - r2;
+                    r2 = r2 + -2;
+                    r16 = r2 & 65535;
+                    r2 = r2 & 32768;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22718;
+                        continue;
+                    }
+                    r2 = 65535 << 16;
+                    r16 = r16 + r2;
+                case 0x22718:
+                    r2 = r16 + 128;
+                    r2 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22760;
+                        continue;
+                    }
+                    r2 = r16 < -128 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22e74;
+                        run_22e00(); return;
+                    }
+                    r7 = r0 + -128;
+                    r7 = r7 - r16;
+                case 0x2273c:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5772;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22754;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x22754:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x22760;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x22760:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x22770;
+                    return;
+                case 0x22770:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x22780;
+                    return;
+                case 0x22780:
+                    /* Next insn is delay slot */ 
+                    r31=0x22788;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x22788:
+                    r2 = r0 + 1;
+                case 0x2278c:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r20 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r19 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r18 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r17 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r16 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x227b0:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x227bc;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x227bc:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x227c8;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x227c8:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22c20;
+                        run_22c00(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22c90;
+                        run_22c00(); return;
+                    }
+                case 0x22800:
+                    pc=0x22800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_22800() throws ExecutionException { /* 0x22800 - 0x22a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x22800:
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r6 = r6 - r2;
+                    r16 = r6 + -3;
+                    r16 = r16 & 65535;
+                case 0x22814:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x22824;
+                    return;
+                case 0x22824:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22830;
+                    pc=0x26000;
+                    run_26000(); return;
+                case 0x22830:
+                    /* Next insn is delay slot */ 
+                    r31=0x22838;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x22838:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22844:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x22854;
+                    return;
+                case 0x22854:
+                    /* Next insn is delay slot */ 
+                    r31=0x2285c;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x2285c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22868:
+                    /* Next insn is delay slot */ 
+                    r31=0x22870;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x22870:
+                    r4 = r29 + 16;
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22880;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x22880:
+                    r3 = r0 + 16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22cbc;
+                        run_22c00(); return;
+                    }
+                    r3 = r2 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22c2c;
+                        run_22c00(); return;
+                    }
+                    r3 = r0 + 24;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22d40;
+                        run_22c00(); return;
+                    }
+                    r3 = r0 + 32;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22b40;
+                        run_22a00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2996;
+                case 0x228bc:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x228d4;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x228d4:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x228e0:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x228ec;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x228ec:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x228fc;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x228fc:
+                    r3 = r0 + 3;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22d54;
+                        run_22c00(); return;
+                    }
+                    r3 = r2 < 4 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22b7c;
+                        run_22a00(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22d68;
+                        run_22c00(); return;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22b40;
+                        run_22a00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2764;
+                case 0x22934:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2294c;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x2294c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22958:
+                    /* Next insn is delay slot */ 
+                    r31=0x22960;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x22960:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2296c;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2296c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22bcc;
+                        run_22a00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x22984;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x22984:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22990:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2299c;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x2299c:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x229ac;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x229ac:
+                    r3 = (r2&0xffffffffL) < (65&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22b40;
+                        run_22a00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -4496;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x229d8:
+                    r3 = 7 << 16;
+                    r4 = readPages[(r3+30664)>>>12][((r3+30664)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -2432;
+                    r17 = r17 + r2;
+                    r4 = r4 & 2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22e8c;
+                        run_22e00(); return;
+                    }
+                case 0x22a00:
+                    pc=0x22a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_22a00() throws ExecutionException { /* 0x22a00 - 0x22c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x22a00:
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22e8c;
+                        run_22e00(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22a38;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r3 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22eac;
+                        run_22e00(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x22a2c:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x22a38:
+                    r3 = r2 << 8;
+                    r6 = r3 | r2;
+                case 0x22a40:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22a50;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x22a50:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22a5c:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2612;
+                case 0x22a64:
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22a7c;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x22a7c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22a88:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2576;
+                    /* Next insn is delay slot */ 
+                    pc=0x22a64;
+                    continue;
+                case 0x22a98:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2360;
+                    /* Next insn is delay slot */ 
+                    pc=0x22a64;
+                    continue;
+                case 0x22aa8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2540;
+                    /* Next insn is delay slot */ 
+                    pc=0x22a64;
+                    continue;
+                case 0x22ab8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2396;
+                    /* Next insn is delay slot */ 
+                    pc=0x22a64;
+                    continue;
+                case 0x22ac8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2468;
+                    /* Next insn is delay slot */ 
+                    pc=0x22a64;
+                    continue;
+                case 0x22ad8:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2324;
+                    /* Next insn is delay slot */ 
+                    pc=0x22934;
+                    run_22800(); return;
+                case 0x22aec:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2256;
+                case 0x22af8:
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22b10;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x22b10:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22b1c:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2504;
+                    /* Next insn is delay slot */ 
+                    pc=0x22a64;
+                    continue;
+                case 0x22b2c:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2120;
+                    /* Next insn is delay slot */ 
+                    pc=0x22af8;
+                    continue;
+                case 0x22b40:
+                    r4 = 7 << 16;
+                    r4 = r4 + -3048;
+                    /* Next insn is delay slot */ 
+                    r31=0x22b50;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x22b50:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22b5c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5732;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22b70;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x22b70:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22b7c:
+                    r3 = r0 + 64;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22d7c;
+                        run_22c00(); return;
+                    }
+                    r3 = r0 + 128;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22b40;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + -2920;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22b40;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x22bc0;
+                    return;
+                case 0x22bc0:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22bcc:
+                    /* Next insn is delay slot */ 
+                    r31=0x22bd4;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x22bd4:
+                    r18 = r2 + r0;
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x22be8;
+                    return;
+                case 0x22be8:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22bf4;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x22bf4:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22c00;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x22c00:
+                    pc=0x22c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_22c00() throws ExecutionException { /* 0x22c00 - 0x22e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x22c00:
+                    /* Next insn is delay slot */ 
+                    r31=0x22c08;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x22c08:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22c14:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x22760;
+                    run_22600(); return;
+                case 0x22c20:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x22814;
+                    run_22800(); return;
+                case 0x22c2c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22b40;
+                        run_22a00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2948;
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x22c58;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x22c58:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22c64:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x22c78;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x22c78:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x22c84;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x22c84:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x22760;
+                    run_22600(); return;
+                case 0x22c90:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x22ca4;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x22ca4:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x22cb0;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x22cb0:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x22814;
+                    run_22800(); return;
+                case 0x22cbc:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2964;
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x22ce0;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x22ce0:
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r0 + 255;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x228d4;
+                        run_22800(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x228d4;
+                        run_22800(); return;
+                    }
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x228d4;
+                        run_22800(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5840;
+                    /* Next insn is delay slot */ 
+                    r31=0x22d34;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x22d34:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22d40:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2980;
+                    /* Next insn is delay slot */ 
+                    pc=0x228bc;
+                    run_22800(); return;
+                case 0x22d54:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2840;
+                    /* Next insn is delay slot */ 
+                    pc=0x22934;
+                    run_22800(); return;
+                case 0x22d68:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2688;
+                    /* Next insn is delay slot */ 
+                    pc=0x22934;
+                    run_22800(); return;
+                case 0x22d7c:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2880;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r17 = 7 << 16;
+                    r3 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r3 & 2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22e80;
+                        run_22e00(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22e80;
+                        run_22e00(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22de4;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r17 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22e98;
+                        run_22e00(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x22dd8:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x22de4:
+                    r16 = r2 << 8;
+                    r16 = r16 | r2;
+                case 0x22dec:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x22e00;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x22e00:
+                    pc=0x22e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_22e00() throws ExecutionException { /* 0x22e00 - 0x23000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x22e00:
+                    r2 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x228d4;
+                        run_22800(); return;
+                    }
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x228d4;
+                        run_22800(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x228d4;
+                        run_22800(); return;
+                    }
+                    r2 = r0 + 139;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x22ec0;
+                        continue;
+                    }
+                    r2 = r0 + 171;
+                    if(r16 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x228d4;
+                        run_22800(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5888;
+                    /* Next insn is delay slot */ 
+                    r31=0x22e68;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x22e68:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x22e74:
+                    r7 = r16 + -127;
+                    /* Next insn is delay slot */ 
+                    pc=0x2273c;
+                    run_22600(); return;
+                case 0x22e80:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x22dec;
+                    run_22c00(); return;
+                case 0x22e8c:
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x22a40;
+                    run_22a00(); return;
+                case 0x22e98:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x22dd8;
+                    run_22c00(); return;
+                case 0x22eac:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x22a2c;
+                    run_22a00(); return;
+                case 0x22ec0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5936;
+                    /* Next insn is delay slot */ 
+                    r31=0x22ed0;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x22ed0:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2278c;
+                    run_22600(); return;
+                case 0x23000:
+                    pc=0x23000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_23000() throws ExecutionException { /* 0x23000 - 0x23200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x23000:
+                    r2 = r0 + 3;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23018;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x23018:
+                    r4 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -136;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r20;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r19;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r18;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r17;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23044;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x23044:
+                    r4 = readPages[(r28+-30696)>>>12][((r28+-30696)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = r29 + 104;
+                    /* Next insn is delay slot */ 
+                    r31=0x23058;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x23058:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230a0;
+                        continue;
+                    }
+                    r16 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r2 = r16 >> 10;
+                    r3 = (r2&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r17 = r16 & 255;
+                    r18 = r16 & 768;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23574;
+                        run_23400(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -4236;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x230a0:
+                    r4 = readPages[(r28+-30700)>>>12][((r28+-30700)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x230b0;
+                    pc=0x21a00;
+                    run_21a00(); return;
+                case 0x230b0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230e0;
+                        continue;
+                    }
+                case 0x230b8:
+                    r2 = r0 + 1;
+                case 0x230bc:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r20 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r19 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r18 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r17 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r16 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x230e0:
+                    r4 = readPages[(r28+-30692)>>>12][((r28+-30692)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x230f0;
+                    pc=0x21a00;
+                    run_21a00(); return;
+                case 0x230f0:
+                    r2 = ((r0 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x230bc;
+                    continue;
+                case 0x230fc:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x23108;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x23108:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x23114;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x23114:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2362c;
+                        run_23600(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23698;
+                        run_23600(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r6 = r6 - r2;
+                    r16 = r6 + -3;
+                    r16 = r16 & 65535;
+                case 0x23160:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x23170;
+                    return;
+                case 0x23170:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2317c;
+                    pc=0x26000;
+                    run_26000(); return;
+                case 0x2317c:
+                    /* Next insn is delay slot */ 
+                    r31=0x23184;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x23184:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    continue;
+                case 0x2318c:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x23198;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x23198:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x231a4;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x231a4:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23620;
+                        run_23600(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2366c;
+                        run_23600(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = r6 - r2;
+                    r2 = r2 + -2;
+                    r16 = r2 & 65535;
+                    r2 = r2 & 32768;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23204;
+                        run_23200(); return;
+                    }
+                    r2 = 65535 << 16;
+                case 0x23200:
+                    pc=0x23200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_23200() throws ExecutionException { /* 0x23200 - 0x23400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x23200:
+                    r16 = r16 + r2;
+                case 0x23204:
+                    r2 = r16 + 128;
+                    r2 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2324c;
+                        continue;
+                    }
+                    r2 = r16 < -128 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23874;
+                        run_23800(); return;
+                    }
+                    r7 = r0 + -128;
+                    r7 = r7 - r16;
+                case 0x23228:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5772;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23240;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x23240:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2324c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2324c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2325c;
+                    return;
+                case 0x2325c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2326c;
+                    return;
+                case 0x2326c:
+                    /* Next insn is delay slot */ 
+                    r31=0x23274;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x23274:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x2327c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2328c;
+                    return;
+                case 0x2328c:
+                    /* Next insn is delay slot */ 
+                    r31=0x23294;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x23294:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x2329c:
+                    /* Next insn is delay slot */ 
+                    r31=0x232a4;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x232a4:
+                    r4 = r29 + 16;
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x232b4;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x232b4:
+                    r3 = r0 + 16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x236c4;
+                        run_23600(); return;
+                    }
+                    r3 = r2 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23638;
+                        run_23600(); return;
+                    }
+                    r3 = r0 + 24;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23744;
+                        run_23600(); return;
+                    }
+                    r3 = r0 + 32;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2355c;
+                        run_23400(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2996;
+                case 0x232f0:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23308;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23308:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23310:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2331c;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x2331c:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2332c;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x2332c:
+                    r3 = r0 + 3;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23758;
+                        run_23600(); return;
+                    }
+                    r3 = r2 < 4 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23590;
+                        run_23400(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2376c;
+                        run_23600(); return;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2355c;
+                        run_23400(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2764;
+                case 0x23364:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2337c;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x2337c:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23384:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23390;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x23390:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x233a0;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x233a0:
+                    r3 = (r2&0xffffffffL) < (65&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2355c;
+                        run_23400(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -4208;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x233cc:
+                    /* Next insn is delay slot */ 
+                    r31=0x233d4;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x233d4:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x233e0;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x233e0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x235dc;
+                        run_23400(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x233f8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x233f8:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23400:
+                    pc=0x23400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_23400() throws ExecutionException { /* 0x23400 - 0x23600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x23400:
+                    r3 = 7 << 16;
+                    r4 = readPages[(r3+30664)>>>12][((r3+30664)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -2432;
+                    r17 = r17 + r2;
+                    r4 = r4 & 2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2388c;
+                        run_23800(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2388c;
+                        run_23800(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23460;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r3 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x238ac;
+                        run_23800(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x23454:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x23460:
+                    r3 = r2 << 8;
+                    r6 = r3 | r2;
+                case 0x23468:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23478;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23478:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23480:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2360;
+                case 0x23488:
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x234a0;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x234a0:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x234a8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2396;
+                    /* Next insn is delay slot */ 
+                    pc=0x23488;
+                    continue;
+                case 0x234b8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2468;
+                    /* Next insn is delay slot */ 
+                    pc=0x23488;
+                    continue;
+                case 0x234c8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2612;
+                    /* Next insn is delay slot */ 
+                    pc=0x23488;
+                    continue;
+                case 0x234d8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2576;
+                    /* Next insn is delay slot */ 
+                    pc=0x23488;
+                    continue;
+                case 0x234e8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2540;
+                    /* Next insn is delay slot */ 
+                    pc=0x23488;
+                    continue;
+                case 0x234f8:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2324;
+                    /* Next insn is delay slot */ 
+                    pc=0x23364;
+                    run_23200(); return;
+                case 0x2350c:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2256;
+                case 0x23518:
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23530;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23530:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23538:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2504;
+                    /* Next insn is delay slot */ 
+                    pc=0x23488;
+                    continue;
+                case 0x23548:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2120;
+                    /* Next insn is delay slot */ 
+                    pc=0x23518;
+                    continue;
+                case 0x2355c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -3048;
+                    /* Next insn is delay slot */ 
+                    r31=0x2356c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2356c:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23574:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5732;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23588;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x23588:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23590:
+                    r3 = r0 + 64;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23780;
+                        run_23600(); return;
+                    }
+                    r3 = r0 + 128;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2355c;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + -2920;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2355c;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x235d4;
+                    return;
+                case 0x235d4:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x235dc:
+                    /* Next insn is delay slot */ 
+                    r31=0x235e4;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x235e4:
+                    r18 = r2 + r0;
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x235f8;
+                    return;
+                case 0x235f8:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23604;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x23600:
+                    pc=0x23600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_23600() throws ExecutionException { /* 0x23600 - 0x23800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x23600:
+                case 0x23604:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23610;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x23610:
+                    /* Next insn is delay slot */ 
+                    r31=0x23618;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x23618:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23620:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2324c;
+                    run_23200(); return;
+                case 0x2362c:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23160;
+                    run_23000(); return;
+                case 0x23638:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2355c;
+                        run_23400(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2948;
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23664;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23664:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x2366c:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x23680;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x23680:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2368c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2368c:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2324c;
+                    run_23200(); return;
+                case 0x23698:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x236ac;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x236ac:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x236b8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x236b8:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23160;
+                    run_23000(); return;
+                case 0x236c4:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2964;
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x236e8;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x236e8:
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r0 + 255;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230b8;
+                        run_23000(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230b8;
+                        run_23000(); return;
+                    }
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230b8;
+                        run_23000(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5840;
+                    /* Next insn is delay slot */ 
+                    r31=0x2373c;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x2373c:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23744:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2980;
+                    /* Next insn is delay slot */ 
+                    pc=0x232f0;
+                    run_23200(); return;
+                case 0x23758:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2840;
+                    /* Next insn is delay slot */ 
+                    pc=0x23364;
+                    run_23200(); return;
+                case 0x2376c:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2688;
+                    /* Next insn is delay slot */ 
+                    pc=0x23364;
+                    run_23200(); return;
+                case 0x23780:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2880;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r17 = 7 << 16;
+                    r3 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r3 & 2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23880;
+                        run_23800(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23880;
+                        run_23800(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x237e8;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r17 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23898;
+                        run_23800(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x237dc:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x237e8:
+                    r16 = r2 << 8;
+                    r16 = r16 | r2;
+                case 0x237f0:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23804;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23800:
+                    pc=0x23800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_23800() throws ExecutionException { /* 0x23800 - 0x23a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x23800:
+                case 0x23804:
+                    r2 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230b8;
+                        run_23000(); return;
+                    }
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230b8;
+                        run_23000(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230b8;
+                        run_23000(); return;
+                    }
+                    r2 = r0 + 139;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x238c0;
+                        continue;
+                    }
+                    r2 = r0 + 171;
+                    if(r16 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x230b8;
+                        run_23000(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5888;
+                    /* Next insn is delay slot */ 
+                    r31=0x2386c;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x2386c:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23874:
+                    r7 = r16 + -127;
+                    /* Next insn is delay slot */ 
+                    pc=0x23228;
+                    run_23200(); return;
+                case 0x23880:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x237f0;
+                    run_23600(); return;
+                case 0x2388c:
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23468;
+                    run_23400(); return;
+                case 0x23898:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x237dc;
+                    run_23600(); return;
+                case 0x238ac:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23454;
+                    run_23400(); return;
+                case 0x238c0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5936;
+                    /* Next insn is delay slot */ 
+                    r31=0x238d0;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x238d0:
+                    /* Next insn is delay slot */ 
+                    pc=0x230b8;
+                    run_23000(); return;
+                case 0x23a00:
+                    pc=0x23a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_23a00() throws ExecutionException { /* 0x23a00 - 0x23c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x23a00:
+                    r2 = r0 + 3;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23a18;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x23a18:
+                    r4 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -136;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r20;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r19;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r18;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r17;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23a44;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x23a44:
+                    r4 = readPages[(r28+-30704)>>>12][((r28+-30704)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = r29 + 104;
+                    /* Next insn is delay slot */ 
+                    r31=0x23a58;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x23a58:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23aa0;
+                        continue;
+                    }
+                    r16 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r2 = r16 >> 10;
+                    r3 = (r2&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r17 = r16 & 255;
+                    r18 = r16 & 768;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23f74;
+                        run_23e00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -3948;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x23aa0:
+                    r4 = readPages[(r28+-30696)>>>12][((r28+-30696)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x23ab0;
+                    pc=0x21a00;
+                    run_21a00(); return;
+                case 0x23ab0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23ae0;
+                        continue;
+                    }
+                case 0x23ab8:
+                    r2 = r0 + 1;
+                case 0x23abc:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r20 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r19 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r18 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r17 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r16 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x23ae0:
+                    r4 = readPages[(r28+-30692)>>>12][((r28+-30692)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x23af0;
+                    pc=0x21a00;
+                    run_21a00(); return;
+                case 0x23af0:
+                    r2 = ((r0 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23abc;
+                    continue;
+                case 0x23afc:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x23b08;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x23b08:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x23b14;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x23b14:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2402c;
+                        run_24000(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24098;
+                        run_24000(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r6 = r6 - r2;
+                    r16 = r6 + -3;
+                    r16 = r16 & 65535;
+                case 0x23b60:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x23b70;
+                    return;
+                case 0x23b70:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23b7c;
+                    pc=0x26000;
+                    run_26000(); return;
+                case 0x23b7c:
+                    /* Next insn is delay slot */ 
+                    r31=0x23b84;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x23b84:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    continue;
+                case 0x23b8c:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x23b98;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x23b98:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x23ba4;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x23ba4:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24020;
+                        run_24000(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2406c;
+                        run_24000(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = r6 - r2;
+                    r2 = r2 + -2;
+                    r16 = r2 & 65535;
+                    r2 = r2 & 32768;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23c04;
+                        run_23c00(); return;
+                    }
+                    r2 = 65535 << 16;
+                case 0x23c00:
+                    pc=0x23c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_23c00() throws ExecutionException { /* 0x23c00 - 0x23e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x23c00:
+                    r16 = r16 + r2;
+                case 0x23c04:
+                    r2 = r16 + 128;
+                    r2 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23c4c;
+                        continue;
+                    }
+                    r2 = r16 < -128 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24274;
+                        run_24200(); return;
+                    }
+                    r7 = r0 + -128;
+                    r7 = r7 - r16;
+                case 0x23c28:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5772;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23c40;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x23c40:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23c4c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x23c4c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x23c5c;
+                    return;
+                case 0x23c5c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x23c6c;
+                    return;
+                case 0x23c6c:
+                    /* Next insn is delay slot */ 
+                    r31=0x23c74;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x23c74:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23c7c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x23c8c;
+                    return;
+                case 0x23c8c:
+                    /* Next insn is delay slot */ 
+                    r31=0x23c94;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x23c94:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23c9c:
+                    /* Next insn is delay slot */ 
+                    r31=0x23ca4;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x23ca4:
+                    r4 = r29 + 16;
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23cb4;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x23cb4:
+                    r3 = r0 + 16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x240c4;
+                        run_24000(); return;
+                    }
+                    r3 = r2 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24038;
+                        run_24000(); return;
+                    }
+                    r3 = r0 + 24;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24144;
+                        run_24000(); return;
+                    }
+                    r3 = r0 + 32;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23f5c;
+                        run_23e00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2996;
+                case 0x23cf0:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23d08;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23d08:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23d10:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23d1c;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x23d1c:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23d2c;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x23d2c:
+                    r3 = r0 + 3;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24158;
+                        run_24000(); return;
+                    }
+                    r3 = r2 < 4 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23f90;
+                        run_23e00(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2416c;
+                        run_24000(); return;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23f5c;
+                        run_23e00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2764;
+                case 0x23d64:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23d7c;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23d7c:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23d84:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x23d90;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x23d90:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23da0;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x23da0:
+                    r3 = (r2&0xffffffffL) < (65&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23f5c;
+                        run_23e00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -3920;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x23dcc:
+                    /* Next insn is delay slot */ 
+                    r31=0x23dd4;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x23dd4:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23de0;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x23de0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23fdc;
+                        run_23e00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x23df8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x23df8:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23e00:
+                    pc=0x23e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_23e00() throws ExecutionException { /* 0x23e00 - 0x24000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x23e00:
+                    r3 = 7 << 16;
+                    r4 = readPages[(r3+30664)>>>12][((r3+30664)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -2432;
+                    r17 = r17 + r2;
+                    r4 = r4 & 2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2428c;
+                        run_24200(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2428c;
+                        run_24200(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23e60;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r3 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x242ac;
+                        run_24200(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x23e54:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x23e60:
+                    r3 = r2 << 8;
+                    r6 = r3 | r2;
+                case 0x23e68:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23e78;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23e78:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23e80:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2360;
+                case 0x23e88:
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23ea0;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23ea0:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23ea8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2396;
+                    /* Next insn is delay slot */ 
+                    pc=0x23e88;
+                    continue;
+                case 0x23eb8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2468;
+                    /* Next insn is delay slot */ 
+                    pc=0x23e88;
+                    continue;
+                case 0x23ec8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2612;
+                    /* Next insn is delay slot */ 
+                    pc=0x23e88;
+                    continue;
+                case 0x23ed8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2576;
+                    /* Next insn is delay slot */ 
+                    pc=0x23e88;
+                    continue;
+                case 0x23ee8:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2540;
+                    /* Next insn is delay slot */ 
+                    pc=0x23e88;
+                    continue;
+                case 0x23ef8:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2324;
+                    /* Next insn is delay slot */ 
+                    pc=0x23d64;
+                    run_23c00(); return;
+                case 0x23f0c:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2256;
+                case 0x23f18:
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23f30;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x23f30:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23f38:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2504;
+                    /* Next insn is delay slot */ 
+                    pc=0x23e88;
+                    continue;
+                case 0x23f48:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2120;
+                    /* Next insn is delay slot */ 
+                    pc=0x23f18;
+                    continue;
+                case 0x23f5c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -3048;
+                    /* Next insn is delay slot */ 
+                    r31=0x23f6c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x23f6c:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23f74:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5732;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x23f88;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x23f88:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23f90:
+                    r3 = r0 + 64;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24180;
+                        run_24000(); return;
+                    }
+                    r3 = r0 + 128;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23f5c;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + -2920;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23f5c;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x23fd4;
+                    return;
+                case 0x23fd4:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x23fdc:
+                    /* Next insn is delay slot */ 
+                    r31=0x23fe4;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x23fe4:
+                    r18 = r2 + r0;
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x23ff8;
+                    return;
+                case 0x23ff8:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24004;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x24000:
+                    pc=0x24000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_24000() throws ExecutionException { /* 0x24000 - 0x24200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x24000:
+                case 0x24004:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24010;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x24010:
+                    /* Next insn is delay slot */ 
+                    r31=0x24018;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x24018:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x24020:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23c4c;
+                    run_23c00(); return;
+                case 0x2402c:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23b60;
+                    run_23a00(); return;
+                case 0x24038:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23f5c;
+                        run_23e00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2948;
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24064;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x24064:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x2406c:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x24080;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x24080:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2408c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2408c:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23c4c;
+                    run_23c00(); return;
+                case 0x24098:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x240ac;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x240ac:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x240b8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x240b8:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23b60;
+                    run_23a00(); return;
+                case 0x240c4:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2964;
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x240e8;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x240e8:
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r0 + 255;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23ab8;
+                        run_23a00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23ab8;
+                        run_23a00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23ab8;
+                        run_23a00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5840;
+                    /* Next insn is delay slot */ 
+                    r31=0x2413c;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x2413c:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x24144:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2980;
+                    /* Next insn is delay slot */ 
+                    pc=0x23cf0;
+                    run_23c00(); return;
+                case 0x24158:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2840;
+                    /* Next insn is delay slot */ 
+                    pc=0x23d64;
+                    run_23c00(); return;
+                case 0x2416c:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2688;
+                    /* Next insn is delay slot */ 
+                    pc=0x23d64;
+                    run_23c00(); return;
+                case 0x24180:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2880;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r17 = 7 << 16;
+                    r3 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r3 & 2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24280;
+                        run_24200(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24280;
+                        run_24200(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x241e8;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r17 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24298;
+                        run_24200(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x241dc:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x241e8:
+                    r16 = r2 << 8;
+                    r16 = r16 | r2;
+                case 0x241f0:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24204;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x24200:
+                    pc=0x24200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_24200() throws ExecutionException { /* 0x24200 - 0x24400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x24200:
+                case 0x24204:
+                    r2 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23ab8;
+                        run_23a00(); return;
+                    }
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23ab8;
+                        run_23a00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23ab8;
+                        run_23a00(); return;
+                    }
+                    r2 = r0 + 139;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x242c0;
+                        continue;
+                    }
+                    r2 = r0 + 171;
+                    if(r16 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x23ab8;
+                        run_23a00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5888;
+                    /* Next insn is delay slot */ 
+                    r31=0x2426c;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x2426c:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x24274:
+                    r7 = r16 + -127;
+                    /* Next insn is delay slot */ 
+                    pc=0x23c28;
+                    run_23c00(); return;
+                case 0x24280:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x241f0;
+                    run_24000(); return;
+                case 0x2428c:
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23e68;
+                    run_23e00(); return;
+                case 0x24298:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x241dc;
+                    run_24000(); return;
+                case 0x242ac:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x23e54;
+                    run_23e00(); return;
+                case 0x242c0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5936;
+                    /* Next insn is delay slot */ 
+                    r31=0x242d0;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x242d0:
+                    /* Next insn is delay slot */ 
+                    pc=0x23ab8;
+                    run_23a00(); return;
+                case 0x24400:
+                    pc=0x24400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_24400() throws ExecutionException { /* 0x24400 - 0x24600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x24400:
+                    r2 = r0 + 3;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24418;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x24418:
+                    r4 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -136;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r20;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r19;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r18;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r17;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24444;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x24444:
+                    r4 = readPages[(r28+-30708)>>>12][((r28+-30708)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = r29 + 104;
+                    /* Next insn is delay slot */ 
+                    r31=0x24458;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x24458:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x244a0;
+                        continue;
+                    }
+                    r16 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r2 = r16 >> 10;
+                    r3 = (r2&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r17 = r16 & 255;
+                    r18 = r16 & 768;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24994;
+                        run_24800(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -3660;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x244a0:
+                    r4 = readPages[(r28+-30692)>>>12][((r28+-30692)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x244b0;
+                    pc=0x21a00;
+                    run_21a00(); return;
+                case 0x244b0:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r20 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r19 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r18 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r17 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r16 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r2 = ((r0 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x244d8:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x244e4;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x244e4:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x244f0;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x244f0:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24a58;
+                        run_24a00(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24ac8;
+                        run_24a00(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r6 = r6 - r2;
+                    r16 = r6 + -3;
+                    r16 = r16 & 65535;
+                case 0x2453c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2454c;
+                    return;
+                case 0x2454c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24558;
+                    pc=0x26000;
+                    run_26000(); return;
+                case 0x24558:
+                    /* Next insn is delay slot */ 
+                    r31=0x24560;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x24560:
+                    r2 = r0 + 1;
+                case 0x24564:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r20 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r19 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r18 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r17 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r16 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x24588:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x24594;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x24594:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x245a0;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x245a0:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24a4c;
+                        run_24a00(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24a9c;
+                        run_24a00(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = r6 - r2;
+                    r2 = r2 + -2;
+                    r16 = r2 & 65535;
+                    r2 = r2 & 32768;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24600;
+                        run_24600(); return;
+                    }
+                    r2 = 65535 << 16;
+                    r16 = r16 + r2;
+                case 0x24600:
+                    pc=0x24600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_24600() throws ExecutionException { /* 0x24600 - 0x24800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x24600:
+                    r2 = r16 + 128;
+                    r2 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24648;
+                        continue;
+                    }
+                    r2 = r16 < -128 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24cac;
+                        run_24c00(); return;
+                    }
+                    r7 = r0 + -128;
+                    r7 = r7 - r16;
+                case 0x24624:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5772;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2463c;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x2463c:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24648;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x24648:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x24658;
+                    return;
+                case 0x24658:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x24668;
+                    return;
+                case 0x24668:
+                    /* Next insn is delay slot */ 
+                    r31=0x24670;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x24670:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x2467c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2468c;
+                    return;
+                case 0x2468c:
+                    /* Next insn is delay slot */ 
+                    r31=0x24694;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x24694:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x246a0:
+                    /* Next insn is delay slot */ 
+                    r31=0x246a8;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x246a8:
+                    r4 = r29 + 16;
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x246b8;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x246b8:
+                    r3 = r0 + 16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24af4;
+                        run_24a00(); return;
+                    }
+                    r3 = r2 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24a64;
+                        run_24a00(); return;
+                    }
+                    r3 = r0 + 24;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24b78;
+                        run_24a00(); return;
+                    }
+                    r3 = r0 + 32;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24978;
+                        run_24800(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2996;
+                case 0x246f4:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2470c;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x2470c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24718:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24724;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x24724:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24734;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x24734:
+                    r3 = r0 + 3;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24b8c;
+                        run_24a00(); return;
+                    }
+                    r3 = r2 < 4 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x249b4;
+                        run_24800(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24ba0;
+                        run_24a00(); return;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24978;
+                        run_24800(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2764;
+                case 0x2476c:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24784;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x24784:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24790:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2479c;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x2479c:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x247ac;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x247ac:
+                    r3 = (r2&0xffffffffL) < (65&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24978;
+                        run_24800(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -3632;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x247d8:
+                    /* Next insn is delay slot */ 
+                    r31=0x247e0;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x247e0:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x247ec;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x247ec:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24a04;
+                        run_24a00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x24804;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x24800:
+                    pc=0x24800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_24800() throws ExecutionException { /* 0x24800 - 0x24a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x24800:
+                case 0x24804:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24810:
+                    r3 = 7 << 16;
+                    r4 = readPages[(r3+30664)>>>12][((r3+30664)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -2432;
+                    r17 = r17 + r2;
+                    r4 = r4 & 2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24cc4;
+                        run_24c00(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24cc4;
+                        run_24c00(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24870;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r3 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24ce4;
+                        run_24c00(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x24864:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x24870:
+                    r3 = r2 << 8;
+                    r6 = r3 | r2;
+                case 0x24878:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24888;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x24888:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24894:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2360;
+                case 0x2489c:
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x248b4;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x248b4:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x248c0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2396;
+                    /* Next insn is delay slot */ 
+                    pc=0x2489c;
+                    continue;
+                case 0x248d0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2468;
+                    /* Next insn is delay slot */ 
+                    pc=0x2489c;
+                    continue;
+                case 0x248e0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2612;
+                    /* Next insn is delay slot */ 
+                    pc=0x2489c;
+                    continue;
+                case 0x248f0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2576;
+                    /* Next insn is delay slot */ 
+                    pc=0x2489c;
+                    continue;
+                case 0x24900:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2540;
+                    /* Next insn is delay slot */ 
+                    pc=0x2489c;
+                    continue;
+                case 0x24910:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2324;
+                    /* Next insn is delay slot */ 
+                    pc=0x2476c;
+                    run_24600(); return;
+                case 0x24924:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2256;
+                case 0x24930:
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24948;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x24948:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24954:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2504;
+                    /* Next insn is delay slot */ 
+                    pc=0x2489c;
+                    continue;
+                case 0x24964:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2120;
+                    /* Next insn is delay slot */ 
+                    pc=0x24930;
+                    continue;
+                case 0x24978:
+                    r4 = 7 << 16;
+                    r4 = r4 + -3048;
+                    /* Next insn is delay slot */ 
+                    r31=0x24988;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x24988:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24994:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5732;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x249a8;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x249a8:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x249b4:
+                    r3 = r0 + 64;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24bb4;
+                        run_24a00(); return;
+                    }
+                    r3 = r0 + 128;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24978;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + -2920;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24978;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x249f8;
+                    return;
+                case 0x249f8:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24a00:
+                    pc=0x24a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_24a00() throws ExecutionException { /* 0x24a00 - 0x24c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x24a00:
+                case 0x24a04:
+                    /* Next insn is delay slot */ 
+                    r31=0x24a0c;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x24a0c:
+                    r18 = r2 + r0;
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x24a20;
+                    return;
+                case 0x24a20:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24a2c;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x24a2c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24a38;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x24a38:
+                    /* Next insn is delay slot */ 
+                    r31=0x24a40;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x24a40:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24a4c:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24648;
+                    run_24600(); return;
+                case 0x24a58:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2453c;
+                    run_24400(); return;
+                case 0x24a64:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24978;
+                        run_24800(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2948;
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24a90;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x24a90:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24a9c:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x24ab0;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x24ab0:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24abc;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x24abc:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24648;
+                    run_24600(); return;
+                case 0x24ac8:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x24adc;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x24adc:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24ae8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x24ae8:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2453c;
+                    run_24400(); return;
+                case 0x24af4:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2964;
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24b18;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x24b18:
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r0 + 255;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24560;
+                        run_24400(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24560;
+                        run_24400(); return;
+                    }
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24560;
+                        run_24400(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5840;
+                    /* Next insn is delay slot */ 
+                    r31=0x24b6c;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x24b6c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24b78:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2980;
+                    /* Next insn is delay slot */ 
+                    pc=0x246f4;
+                    run_24600(); return;
+                case 0x24b8c:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2840;
+                    /* Next insn is delay slot */ 
+                    pc=0x2476c;
+                    run_24600(); return;
+                case 0x24ba0:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2688;
+                    /* Next insn is delay slot */ 
+                    pc=0x2476c;
+                    run_24600(); return;
+                case 0x24bb4:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2880;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r17 = 7 << 16;
+                    r3 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r3 & 2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24cb8;
+                        run_24c00(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24cb8;
+                        run_24c00(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24c1c;
+                        run_24c00(); return;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r17 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24cd0;
+                        run_24c00(); return;
+                    }
+                case 0x24c00:
+                    pc=0x24c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_24c00() throws ExecutionException { /* 0x24c00 - 0x24e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x24c00:
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x24c10:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x24c1c:
+                    r16 = r2 << 8;
+                    r16 = r16 | r2;
+                case 0x24c24:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24c38;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x24c38:
+                    r2 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24560;
+                        run_24400(); return;
+                    }
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24560;
+                        run_24400(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24560;
+                        run_24400(); return;
+                    }
+                    r2 = r0 + 139;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24cf8;
+                        continue;
+                    }
+                    r2 = r0 + 171;
+                    if(r16 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24560;
+                        run_24400(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5888;
+                    /* Next insn is delay slot */ 
+                    r31=0x24ca0;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x24ca0:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24cac:
+                    r7 = r16 + -127;
+                    /* Next insn is delay slot */ 
+                    pc=0x24624;
+                    run_24600(); return;
+                case 0x24cb8:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24c24;
+                    continue;
+                case 0x24cc4:
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24878;
+                    run_24800(); return;
+                case 0x24cd0:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24c10;
+                    continue;
+                case 0x24ce4:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24864;
+                    run_24800(); return;
+                case 0x24cf8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5936;
+                    /* Next insn is delay slot */ 
+                    r31=0x24d08;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x24d08:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x24564;
+                    run_24400(); return;
+                case 0x24e00:
+                    pc=0x24e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_24e00() throws ExecutionException { /* 0x24e00 - 0x25000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x24e00:
+                    r2 = r0 + 3;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24e18;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x24e18:
+                    r4 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -136;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r20;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r19;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r18;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r17;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x24e44;
+                    pc=0x18000;
+                    run_18000(); return;
+                case 0x24e44:
+                    r4 = readPages[(r28+-30716)>>>12][((r28+-30716)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    r5 = r29 + 104;
+                    /* Next insn is delay slot */ 
+                    r31=0x24e58;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x24e58:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24ea0;
+                        continue;
+                    }
+                    r16 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r2 = r16 >> 10;
+                    r3 = (r2&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r17 = r16 & 255;
+                    r18 = r16 & 768;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2538c;
+                        run_25200(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -3372;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x24ea0:
+                    r4 = readPages[(r28+-30708)>>>12][((r28+-30708)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x24eb0;
+                    pc=0x21a00;
+                    run_21a00(); return;
+                case 0x24eb0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24ee0;
+                        continue;
+                    }
+                case 0x24eb8:
+                    r2 = r0 + 1;
+                case 0x24ebc:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r20 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r19 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r18 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r17 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r16 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x24ee0:
+                    r4 = readPages[(r28+-30692)>>>12][((r28+-30692)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x24ef0;
+                    pc=0x21a00;
+                    run_21a00(); return;
+                case 0x24ef0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24eb8;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30712)>>>12][((r28+-30712)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-30688)>>>12][((r28+-30688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x24f08;
+                    pc=0x21a00;
+                    run_21a00(); return;
+                case 0x24f08:
+                    r2 = ((r0 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24ebc;
+                    continue;
+                case 0x24f14:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x24f20;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x24f20:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x24f2c;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x24f2c:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25444;
+                        run_25400(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x254b0;
+                        run_25400(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r6 = r6 - r2;
+                    r16 = r6 + -3;
+                    r16 = r16 & 65535;
+                case 0x24f78:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x24f88;
+                    return;
+                case 0x24f88:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x24f94;
+                    pc=0x26000;
+                    run_26000(); return;
+                case 0x24f94:
+                    /* Next insn is delay slot */ 
+                    r31=0x24f9c;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x24f9c:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    continue;
+                case 0x24fa4:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x24fb0;
+                    pc=0x15c00;
+                    run_15c00(); return;
+                case 0x24fb0:
+                    r4 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    r31=0x24fbc;
+                    pc=0x32200;
+                    run_32200(); return;
+                case 0x24fbc:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r3 = r4 & r3;
+                    r3 = r3 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25438;
+                        run_25400(); return;
+                    }
+                    r6 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r3 = r0 | 65535;
+                    r4 = r6 | 65535;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25484;
+                        run_25400(); return;
+                    }
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = r6 - r2;
+                case 0x25000:
+                    pc=0x25000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_25000() throws ExecutionException { /* 0x25000 - 0x25200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x25000:
+                    r2 = r2 + -2;
+                    r16 = r2 & 65535;
+                    r2 = r2 & 32768;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2501c;
+                        continue;
+                    }
+                    r2 = 65535 << 16;
+                    r16 = r16 + r2;
+                case 0x2501c:
+                    r2 = r16 + 128;
+                    r2 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25064;
+                        continue;
+                    }
+                    r2 = r16 < -128 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2568c;
+                        run_25600(); return;
+                    }
+                    r7 = r0 + -128;
+                    r7 = r7 - r16;
+                case 0x25040:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5772;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x25058;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x25058:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x25064;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x25064:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x25074;
+                    return;
+                case 0x25074:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x25084;
+                    return;
+                case 0x25084:
+                    /* Next insn is delay slot */ 
+                    r31=0x2508c;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x2508c:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x25094:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x250a4;
+                    return;
+                case 0x250a4:
+                    /* Next insn is delay slot */ 
+                    r31=0x250ac;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x250ac:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x250b4:
+                    /* Next insn is delay slot */ 
+                    r31=0x250bc;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x250bc:
+                    r4 = r29 + 16;
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x250cc;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x250cc:
+                    r3 = r0 + 16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x254dc;
+                        run_25400(); return;
+                    }
+                    r3 = r2 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25450;
+                        run_25400(); return;
+                    }
+                    r3 = r0 + 24;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2555c;
+                        run_25400(); return;
+                    }
+                    r3 = r0 + 32;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25374;
+                        run_25200(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2996;
+                case 0x25108:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x25120;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x25120:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x25128:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x25134;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x25134:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x25144;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x25144:
+                    r3 = r0 + 3;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25570;
+                        run_25400(); return;
+                    }
+                    r3 = r2 < 4 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x253a8;
+                        run_25200(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25584;
+                        run_25400(); return;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25374;
+                        run_25200(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2764;
+                case 0x2517c:
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x25194;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x25194:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x2519c:
+                    r19 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x251a8;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x251a8:
+                    r4 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x251b8;
+                    pc=0x21400;
+                    run_21400(); return;
+                case 0x251b8:
+                    r3 = (r2&0xffffffffL) < (65&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25374;
+                        run_25200(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + -3344;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x251e4:
+                    /* Next insn is delay slot */ 
+                    r31=0x251ec;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x251ec:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x251f8;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x251f8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x253f4;
+                        run_25200(); return;
+                    }
+                case 0x25200:
+                    pc=0x25200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_25200() throws ExecutionException { /* 0x25200 - 0x25400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x25200:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x25210;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x25210:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x25218:
+                    r3 = 7 << 16;
+                    r4 = readPages[(r3+30664)>>>12][((r3+30664)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r2 = r2 + -2432;
+                    r17 = r17 + r2;
+                    r4 = r4 & 2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x256a4;
+                        run_25600(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x256a4;
+                        run_25600(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25278;
+                        continue;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r3 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x256c4;
+                        run_25600(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x2526c:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x25278:
+                    r3 = r2 << 8;
+                    r6 = r3 | r2;
+                case 0x25280:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x25290;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x25290:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x25298:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2360;
+                case 0x252a0:
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x252b8;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x252b8:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x252c0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2396;
+                    /* Next insn is delay slot */ 
+                    pc=0x252a0;
+                    continue;
+                case 0x252d0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2468;
+                    /* Next insn is delay slot */ 
+                    pc=0x252a0;
+                    continue;
+                case 0x252e0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2612;
+                    /* Next insn is delay slot */ 
+                    pc=0x252a0;
+                    continue;
+                case 0x252f0:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2576;
+                    /* Next insn is delay slot */ 
+                    pc=0x252a0;
+                    continue;
+                case 0x25300:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2540;
+                    /* Next insn is delay slot */ 
+                    pc=0x252a0;
+                    continue;
+                case 0x25310:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2324;
+                    /* Next insn is delay slot */ 
+                    pc=0x2517c;
+                    run_25000(); return;
+                case 0x25324:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2256;
+                case 0x25330:
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x25348;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x25348:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x25350:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2504;
+                    /* Next insn is delay slot */ 
+                    pc=0x252a0;
+                    continue;
+                case 0x25360:
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2120;
+                    /* Next insn is delay slot */ 
+                    pc=0x25330;
+                    continue;
+                case 0x25374:
+                    r4 = 7 << 16;
+                    r4 = r4 + -3048;
+                    /* Next insn is delay slot */ 
+                    r31=0x25384;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x25384:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x2538c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5732;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x253a0;
+                    pc=0x1b800;
+                    run_1b800(); return;
+                case 0x253a0:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x253a8:
+                    r3 = r0 + 64;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25598;
+                        run_25400(); return;
+                    }
+                    r3 = r0 + 128;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25374;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + -2920;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25374;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x253ec;
+                    return;
+                case 0x253ec:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x253f4:
+                    /* Next insn is delay slot */ 
+                    r31=0x253fc;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x253fc:
+                    r18 = r2 + r0;
+                case 0x25400:
+                    pc=0x25400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_25400() throws ExecutionException { /* 0x25400 - 0x25600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x25400:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x25410;
+                    return;
+                case 0x25410:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2541c;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2541c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x25428;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x25428:
+                    /* Next insn is delay slot */ 
+                    r31=0x25430;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x25430:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x25438:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x25064;
+                    run_25000(); return;
+                case 0x25444:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24f78;
+                    run_24e00(); return;
+                case 0x25450:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25374;
+                        run_25200(); return;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 2;
+                    r2 = r2 + -2948;
+                    r2 = r17 + r2;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2547c;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x2547c:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x25484:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x25498;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x25498:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x254a4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x254a4:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x25064;
+                    run_25000(); return;
+                case 0x254b0:
+                    r5 = 7 << 16;
+                    r4 = r29 + 16;
+                    r5 = r5 + -5800;
+                    /* Next insn is delay slot */ 
+                    r31=0x254c4;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x254c4:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x254d0;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x254d0:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x24f78;
+                    run_24e00(); return;
+                case 0x254dc:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2964;
+                    r2 = r17 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x25500;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x25500:
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r0 + 255;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24eb8;
+                        run_24e00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24eb8;
+                        run_24e00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30664)>>>12][((r2+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24eb8;
+                        run_24e00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5840;
+                    /* Next insn is delay slot */ 
+                    r31=0x25554;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x25554:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x2555c:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2980;
+                    /* Next insn is delay slot */ 
+                    pc=0x25108;
+                    run_25000(); return;
+                case 0x25570:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2840;
+                    /* Next insn is delay slot */ 
+                    pc=0x2517c;
+                    run_25000(); return;
+                case 0x25584:
+                    r2 = 7 << 16;
+                    r17 = r17 << 1;
+                    r2 = r2 + -2688;
+                    /* Next insn is delay slot */ 
+                    pc=0x2517c;
+                    run_25000(); return;
+                case 0x25598:
+                    r2 = 7 << 16;
+                    r2 = r2 + -2880;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r17 = 7 << 16;
+                    r3 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r3 & 2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25698;
+                        run_25600(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25698;
+                        run_25600(); return;
+                    }
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25600;
+                        run_25600(); return;
+                    }
+                    r16 = r16 & 256;
+                    r3 = r17 + 30664;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x256b0;
+                        run_25600(); return;
+                    }
+                    r20 = readPages[(r3+36)>>>12][((r3+36)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                case 0x255f4:
+                    r20 = (r20&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 2;
+                    r20 = r3 - r20;
+                case 0x25600:
+                    pc=0x25600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_25600() throws ExecutionException { /* 0x25600 - 0x25800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x25600:
+                    r16 = r2 << 8;
+                    r16 = r16 | r2;
+                case 0x25608:
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2561c;
+                    pc=0x21000;
+                    run_21000(); return;
+                case 0x2561c:
+                    r2 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24eb8;
+                        run_24e00(); return;
+                    }
+                    addr=r29+27;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24eb8;
+                        run_24e00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24eb8;
+                        run_24e00(); return;
+                    }
+                    r2 = r0 + 139;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x256d8;
+                        continue;
+                    }
+                    r2 = r0 + 171;
+                    if(r16 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x24eb8;
+                        run_24e00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -5888;
+                    /* Next insn is delay slot */ 
+                    r31=0x25684;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x25684:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x2568c:
+                    r7 = r16 + -127;
+                    /* Next insn is delay slot */ 
+                    pc=0x25040;
+                    run_25000(); return;
+                case 0x25698:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x25608;
+                    continue;
+                case 0x256a4:
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x25280;
+                    run_25200(); return;
+                case 0x256b0:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x255f4;
+                    run_25400(); return;
+                case 0x256c4:
+                    r20 = readPages[(r3+40)>>>12][((r3+40)>>>2)&0x3ff];
+                    r20 = ((r0 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2526c;
+                    run_25200(); return;
+                case 0x256d8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -5936;
+                    /* Next insn is delay slot */ 
+                    r31=0x256e8;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x256e8:
+                    /* Next insn is delay slot */ 
+                    pc=0x24eb8;
+                    run_24e00(); return;
+                case 0x25800:
+                    pc=0x25800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_25800() throws ExecutionException { /* 0x25800 - 0x25a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x25800:
+                    r29 = r29 + -40;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    r18 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = r18 + 16880;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r2 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r17 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r2 = r2 < r17 ? 1 : 0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    r19 = r4 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25914;
+                        continue;
+                    }
+                    r2 = r17 + r0;
+                case 0x2583c:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r3 = r2 < r3 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25854;
+                        continue;
+                    }
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                case 0x25854:
+                    r3 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = r3 < r2 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2586c;
+                        continue;
+                    }
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r2;
+                case 0x2586c:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r5 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25904;
+                        continue;
+                    }
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x258f8;
+                        continue;
+                    }
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r2;
+                case 0x25898:
+                    r4 = r19 << 24;
+                    r6 = r5 + 1;
+                    r4 = r4 >> 24;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r6;
+                    r3 = r3 + r5;
+                    addr=r3+1044;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x258b0:
+                    r3 = readPages[(r18+16880)>>>12][((r18+16880)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff];
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff] = r3;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x258f8:
+                    r4 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25898;
+                        continue;
+                    }
+                case 0x25904:
+                    r4 = r19 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x258b0;
+                    continue;
+                case 0x25914:
+                    r2 = 1 << 16;
+                    r2 = r17 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x259b4;
+                        continue;
+                    }
+                case 0x25924:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25940;
+                        continue;
+                    }
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x2583c;
+                    continue;
+                case 0x25940:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1960;
+                    /* Next insn is delay slot */ 
+                    r31=0x25950;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x25950:
+                    r4 = r17 + 1;
+                    r3 = readPages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff];
+                    r17 = r17 + 2;
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r17;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r5 = r4 < r2 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25990;
+                        continue;
+                    }
+                case 0x25974:
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r5 = r4 < r2 ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25974;
+                        continue;
+                    }
+                case 0x25990:
+                    r4 = 7 << 16;
+                    r4 = r4 + 16912;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x259cc;
+                        continue;
+                    }
+                    r2 = r2 + -1;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x2583c;
+                    continue;
+                case 0x259b4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1984;
+                    /* Next insn is delay slot */ 
+                    r31=0x259c4;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x259c4:
+                    /* Next insn is delay slot */ 
+                    pc=0x25924;
+                    continue;
+                case 0x259cc:
+                    r2 = r0 | 65535;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x2583c;
+                    continue;
+                case 0x25a00:
+                    pc=0x25a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_25a00() throws ExecutionException { /* 0x25a00 - 0x25c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x25a00:
+                    r29 = r29 + -40;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r19 = r4 + r0;
+                    r4 = 7 << 16;
+                    r4 = r4 + -6964;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    r18 = 7 << 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x25a30;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x25a30:
+                    r2 = 2 << 16;
+                    r2 = r2 + 22528;
+                    r16 = r18 + 16880;
+                    writePages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff] = r2;
+                    r17 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 < r17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25b34;
+                        continue;
+                    }
+                    r2 = r17 + r0;
+                case 0x25a5c:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r3 = r2 < r3 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25a74;
+                        continue;
+                    }
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                case 0x25a74:
+                    r3 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = r3 < r2 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25a8c;
+                        continue;
+                    }
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r2;
+                case 0x25a8c:
+                    r3 = readPages[(r28+-30752)>>>12][((r28+-30752)>>>2)&0x3ff];
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25b24;
+                        continue;
+                    }
+                    r5 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25b18;
+                        continue;
+                    }
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r2;
+                case 0x25ab8:
+                    r4 = r19 << 24;
+                    r6 = r5 + 1;
+                    r4 = r4 >> 24;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r6;
+                    r3 = r3 + r5;
+                    addr=r3+1044;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x25ad0:
+                    r3 = readPages[(r18+16880)>>>12][((r18+16880)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r5;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff];
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff] = r3;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x25b18:
+                    r4 = (r5&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25ab8;
+                        continue;
+                    }
+                case 0x25b24:
+                    r4 = r19 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x25ad0;
+                    continue;
+                case 0x25b34:
+                    r2 = 1 << 16;
+                    r2 = r17 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25bd4;
+                        continue;
+                    }
+                case 0x25b44:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25b60;
+                        continue;
+                    }
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x25a5c;
+                    continue;
+                case 0x25b60:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1960;
+                    /* Next insn is delay slot */ 
+                    r31=0x25b70;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x25b70:
+                    r5 = r17 + 1;
+                    r3 = readPages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff];
+                    r17 = r17 + 2;
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r17;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r4 = r5 < r2 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25bb0;
+                        continue;
+                    }
+                case 0x25b94:
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r4 = r5 < r2 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25b94;
+                        continue;
+                    }
+                case 0x25bb0:
+                    r4 = 7 << 16;
+                    r4 = r4 + 16912;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25bec;
+                        continue;
+                    }
+                    r2 = r2 + -1;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x25a5c;
+                    continue;
+                case 0x25bd4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1984;
+                    /* Next insn is delay slot */ 
+                    r31=0x25be4;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x25be4:
+                    /* Next insn is delay slot */ 
+                    pc=0x25b44;
+                    continue;
+                case 0x25bec:
+                    r2 = r0 | 65535;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x25a5c;
+                    continue;
+                case 0x25c00:
+                    pc=0x25c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_25c00() throws ExecutionException { /* 0x25c00 - 0x25e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x25c00:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r18 = r4 + r0;
+                    if(r4 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25c9c;
+                        continue;
+                    }
+                    r2 = 2 << 16;
+                    r3 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r2 = r2 + 23040;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25d80;
+                        continue;
+                    }
+                case 0x25c34:
+                    r16 = 7 << 16;
+                    r16 = r16 + 16880;
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r4 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r17 = r3 + r18;
+                    r2 = r17 + -1;
+                    r4 = r4 < r2 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25cc4;
+                        continue;
+                    }
+                case 0x25c58:
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r4 = r3 < r4 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25c70;
+                        continue;
+                    }
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r3;
+                case 0x25c70:
+                    r3 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = r3 < r2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25cb8;
+                        continue;
+                    }
+                case 0x25c84:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff];
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r17;
+                    r18 = r3 + r18;
+                    writePages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff] = r18;
+                case 0x25c9c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x25cb8:
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x25c84;
+                    continue;
+                case 0x25cc4:
+                    r3 = 1 << 16;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25d68;
+                        continue;
+                    }
+                case 0x25cd4:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25cfc;
+                        continue;
+                    }
+                case 0x25ce4:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r17 = r18 + r3;
+                    r2 = r17 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x25c58;
+                    continue;
+                case 0x25cfc:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1960;
+                    /* Next insn is delay slot */ 
+                    r31=0x25d0c;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x25d0c:
+                    r3 = r17 + 1;
+                    r2 = readPages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff];
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r17 < r3 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25d48;
+                        continue;
+                    }
+                case 0x25d2c:
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r17 < r3 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25d2c;
+                        continue;
+                    }
+                case 0x25d48:
+                    r4 = 7 << 16;
+                    r4 = r4 + 16912;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25d98;
+                        continue;
+                    }
+                    r3 = r3 + -1;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x25ce4;
+                    continue;
+                case 0x25d68:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1984;
+                    /* Next insn is delay slot */ 
+                    r31=0x25d78;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x25d78:
+                    /* Next insn is delay slot */ 
+                    pc=0x25cd4;
+                    continue;
+                case 0x25d80:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x25d8c;
+                    pc=0x25a00;
+                    run_25a00(); return;
+                case 0x25d8c:
+                    r18 = r18 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x25c34;
+                    continue;
+                case 0x25d98:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r0 | 65535;
+                    r17 = r18 + r3;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r2;
+                    r2 = r17 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x25c58;
+                    continue;
+                case 0x25e00:
+                    pc=0x25e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_25e00() throws ExecutionException { /* 0x25e00 - 0x26000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x25e00:
+                    r2 = r4 + 128;
+                    r2 = (r2&0xffffffffL) < (384&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x25e20;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6936;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x25e20:
+                    r25 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x26000:
+                    pc=0x26000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_26000() throws ExecutionException { /* 0x26000 - 0x26200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x26000:
+                    r3 = r0 | 32768;
+                    r2 = 1 << 16;
+                    r3 = r4 + r3;
+                    r2 = r2 | 32768;
+                    r29 = r29 + -24;
+                    r2 = ((r3 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x26048;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -6936;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x26048:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x26058;
+                    return;
+                case 0x26058:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r16 >> 8;
+                    r25 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x26200:
+                    pc=0x26200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_26200() throws ExecutionException { /* 0x26200 - 0x26400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x26200:
+                    r2 = 128 << 16;
+                    r2 = r4 + r2;
+                    r3 = 384 << 16;
+                    r29 = r29 + -24;
+                    r2 = ((r2 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x26244;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -6936;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x26244:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x26254;
+                    return;
+                case 0x26254:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 >> 8;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x26264;
+                    return;
+                case 0x26264:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r16 >> 16;
+                    r25 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x26400:
+                    pc=0x26400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_26400() throws ExecutionException { /* 0x26400 - 0x26600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x26400:
+                    r29 = r29 + -24;
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2641c;
+                    return;
+                case 0x2641c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 >> 8;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2642c;
+                    return;
+                case 0x2642c:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r16 >> 16;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2643c;
+                    return;
+                case 0x2643c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r16 >> 24;
+                    r25 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r25;
+                    return;
+                case 0x26600:
+                    pc=0x26600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_26600() throws ExecutionException { /* 0x26600 - 0x26800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x26600:
+                    r2 = 7 << 16;
+                    r29 = r29 + -32;
+                    r3 = r2 + 16880;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff];
+                    r5 = r4 << 24;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r5 = r5 >> 24;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x26674;
+                        continue;
+                    }
+                    r4 = readPages[(r2+16880)>>>12][((r2+16880)>>>2)&0x3ff];
+                    r17 = r0 + 1;
+                    r6 = 1 << 16;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x26644;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x26644:
+                    r2 = readPages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x26658;
+                        continue;
+                    }
+                    writePages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff] = r17;
+                case 0x26658:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x26674:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1912;
+                    /* Next insn is delay slot */ 
+                    r31=0x26684;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x26684:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = r0 + 1;
+                    r2 = r16 + r0;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x26800:
+                    pc=0x26800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_26800() throws ExecutionException { /* 0x26800 - 0x26a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x26800:
+                    r4 = readPages[(r28+-30680)>>>12][((r28+-30680)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2685c;
+                        continue;
+                    }
+                case 0x26814:
+                    r6 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x26824;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x26824:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x26848;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    writePages[(r28+-30684)>>>12][((r28+-30684)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x26848:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2685c:
+                    r5 = 7 << 16;
+                    r4 = r28 + -30680;
+                    r5 = r5 + 8880;
+                    /* Next insn is delay slot */ 
+                    r31=0x26870;
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x26870:
+                    r4 = readPages[(r28+-30680)>>>12][((r28+-30680)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x26814;
+                    continue;
+                case 0x26a00:
+                    pc=0x26a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_26a00() throws ExecutionException { /* 0x26a00 - 0x26c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x26a00:
+                    r2 = readPages[(r28+-30684)>>>12][((r28+-30684)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x26a24;
+                        continue;
+                    }
+                    r2 = r0 + 2;
+                    writePages[(r28+-30684)>>>12][((r28+-30684)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x26a24:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x26c00:
+                    pc=0x26c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_26c00() throws ExecutionException { /* 0x26c00 - 0x26e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x26c00:
+                    r2 = readPages[(r28+-30848)>>>12][((r28+-30848)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x26c38;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -1884;
+                    /* Next insn is delay slot */ 
+                    r31=0x26c24;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x26c24:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x26c38:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x26c44;
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x26c44:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30848)>>>12][((r28+-30848)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x26e00:
+                    pc=0x26e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_26e00() throws ExecutionException { /* 0x26e00 - 0x27000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x26e00:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = 1 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = 7 << 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x26e24;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x26e24:
+                    r3 = r0 + 256;
+                    writePages[(r16+16880)>>>12][((r16+16880)>>>2)&0x3ff] = r2;
+                    if(r17 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x26e80;
+                        continue;
+                    }
+                    r5 = r17 << 24;
+                    r5 = r5 >> 24;
+                    r3 = r0 + 1;
+                case 0x26e40:
+                    r16 = r16 + 16880;
+                    r4 = r2 + r0;
+                    r6 = 1 << 16;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x26e58;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x26e58:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r2 = r2 + 16912;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    writePages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff] = r2;
+                    writePages[(r16+36)>>>12][((r16+36)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x26e80:
+                    r5 = r0 + r0;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x26e40;
+                    continue;
+                case 0x27000:
+                    pc=0x27000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_27000() throws ExecutionException { /* 0x27000 - 0x27200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x27000:
+                    r29 = r29 + -56;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    r19 = 7 << 16;
+                    r2 = r19 + 16880;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    r18 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r17 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    r2 = r18 < r17 ? 1 : 0;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r20;
+                    r16 = r4 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2711c;
+                        continue;
+                    }
+                    r18 = r18 - r17;
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r18 = r18 + 1;
+                    r21 = r17 + r0;
+                    r20 = r18 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27138;
+                        continue;
+                    }
+                case 0x2705c:
+                    r2 = readPages[(r28+-30684)>>>12][((r28+-30684)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2716c;
+                        continue;
+                    }
+                case 0x2706c:
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x270e0;
+                        continue;
+                    }
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x273dc;
+                        run_27200(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                case 0x270a4:
+                    r2 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x270ac:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27394;
+                        run_27200(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r17 = r17 >> 8;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                case 0x270d8:
+                    r2 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x270e0:
+                    r4 = readPages[(r19+16880)>>>12][((r19+16880)>>>2)&0x3ff];
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r4 = r4 + r21;
+                    r5 = r20 + r0;
+                    r21 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r20 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r7 = r16 + r0;
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r6 = r0 + 1;
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x2711c:
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r20 = r0 + r0;
+                    r21 = r0 + r0;
+                    r18 = r0 + r0;
+                    r17 = r0 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2705c;
+                        continue;
+                    }
+                case 0x27138:
+                    r2 = r17 + r18;
+                    r4 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = r4 + -1856;
+                    r5 = r18 + r0;
+                    r6 = r18 + r0;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2715c;
+                    pc=0x3fc00;
+                    run_3fc00(); return;
+                case 0x2715c:
+                    r2 = readPages[(r28+-30684)>>>12][((r28+-30684)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2706c;
+                        continue;
+                    }
+                case 0x2716c:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27340;
+                        run_27200(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                case 0x27198:
+                    r2 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x271a0:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x272ec;
+                        run_27200(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r17 = r17 >> 8;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                case 0x271cc:
+                    r2 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x271d4:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27298;
+                        run_27200(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                case 0x27200:
+                    pc=0x27200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_27200() throws ExecutionException { /* 0x27200 - 0x27400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x27200:
+                    r2 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x27208:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27244;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r18 = r18 >> 8;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x270e0;
+                    run_27000(); return;
+                case 0x27244:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x274a0;
+                        run_27400(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r18 = r18 >> 8;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x270d8;
+                        run_27000(); return;
+                    }
+                case 0x2727c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r0 + 10;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x27290;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x27290:
+                    /* Next insn is delay slot */ 
+                    pc=0x270e0;
+                    run_27000(); return;
+                case 0x27298:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2744c;
+                        run_27400(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27200;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r0 + 10;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x272e4;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x272e4:
+                    /* Next insn is delay slot */ 
+                    pc=0x27208;
+                    continue;
+                case 0x272ec:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27430;
+                        run_27400(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r17 = r17 >> 8;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x271cc;
+                        run_27000(); return;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r0 + 10;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x27338;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x27338:
+                    /* Next insn is delay slot */ 
+                    pc=0x271d4;
+                    run_27000(); return;
+                case 0x27340:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27468;
+                        run_27400(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27198;
+                        run_27000(); return;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r0 + 10;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2738c;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x2738c:
+                    /* Next insn is delay slot */ 
+                    pc=0x271a0;
+                    run_27000(); return;
+                case 0x27394:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x274bc;
+                        run_27400(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r17 = r17 >> 8;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2727c;
+                        continue;
+                    }
+                    r2 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x270e0;
+                    run_27000(); return;
+                case 0x273dc:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27484;
+                        run_27400(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                case 0x27400:
+                    pc=0x27400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_27400() throws ExecutionException { /* 0x27400 - 0x27600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x27400:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x270a4;
+                        run_27000(); return;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r0 + 10;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x27428;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x27428:
+                    /* Next insn is delay slot */ 
+                    pc=0x270ac;
+                    run_27000(); return;
+                case 0x27430:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r17 >> 8;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x27444;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x27444:
+                    /* Next insn is delay slot */ 
+                    pc=0x271d4;
+                    run_27000(); return;
+                case 0x2744c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r18 & 255;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x27460;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x27460:
+                    /* Next insn is delay slot */ 
+                    pc=0x27208;
+                    run_27200(); return;
+                case 0x27468:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r17 & 255;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2747c;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x2747c:
+                    /* Next insn is delay slot */ 
+                    pc=0x271a0;
+                    run_27000(); return;
+                case 0x27484:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r17 & 255;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x27498;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x27498:
+                    /* Next insn is delay slot */ 
+                    pc=0x270ac;
+                    run_27000(); return;
+                case 0x274a0:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r18 >> 8;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x274b4;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x274b4:
+                    /* Next insn is delay slot */ 
+                    pc=0x270e0;
+                    run_27000(); return;
+                case 0x274bc:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r17 >> 8;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x274d0;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x274d0:
+                    /* Next insn is delay slot */ 
+                    pc=0x270e0;
+                    run_27000(); return;
+                case 0x27600:
+                    pc=0x27600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_27600() throws ExecutionException { /* 0x27600 - 0x27800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x27600:
+                    r4 = 2 << 16;
+                    r4 = r4 + 23040;
+                    r2 = 7 << 16;
+                    r2 = r2 + 16880;
+                    r3 = r0 | 65535;
+                    writePages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff] = r4;
+                    r4 = r0 + -1;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    writePages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff] = r4;
+                    writePages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff] = r3;
+                    writePages[(r2+28)>>>12][((r2+28)>>>2)&0x3ff] = r0;
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    writePages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff] = r0;
+                    writePages[(r2+36)>>>12][((r2+36)>>>2)&0x3ff] = r0;
+                    writePages[(r2+40)>>>12][((r2+40)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x27800:
+                    pc=0x27800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_27800() throws ExecutionException { /* 0x27800 - 0x27a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x27800:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r29 = r29 + -48;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27864;
+                        continue;
+                    }
+                    r17 = 7 << 16;
+                    r17 = r17 + 16880;
+                    r18 = readPages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27864;
+                        continue;
+                    }
+                    r2 = readPages[(r17+28)>>>12][((r17+28)>>>2)&0x3ff];
+                    r2 = r2 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27864;
+                        continue;
+                    }
+                    r19 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r19 = r19 - r18;
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27884;
+                        continue;
+                    }
+                case 0x27864:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x27884:
+                    r4 = r0 + 16;
+                    r16 = readPages[(r17+32)>>>12][((r17+32)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x27894;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x27894:
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r18;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r19;
+                    writePages[(r17+40)>>>12][((r17+40)>>>2)&0x3ff] = r18;
+                    r3 = r19 + 1;
+                    r6 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r17+44)>>>12][((r17+44)>>>2)&0x3ff] = r3;
+                case 0x278ac:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r4 = r3 < r6 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x278e0;
+                        continue;
+                    }
+                    if(r6 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x278ec;
+                        continue;
+                    }
+                    r4 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r3 = r4 < r3 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x278ec;
+                        continue;
+                    }
+                case 0x278e0:
+                    r16 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x278ac;
+                    continue;
+                case 0x278ec:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r16;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27864;
+                        continue;
+                    }
+                    r2 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r7 = readPages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = r4 + -1800;
+                    r5 = r19 + r0;
+                    r6 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x27940;
+                    pc=0x3fc00;
+                    run_3fc00(); return;
+                case 0x27940:
+                    /* Next insn is delay slot */ 
+                    pc=0x27864;
+                    continue;
+                case 0x27a00:
+                    pc=0x27a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_27a00() throws ExecutionException { /* 0x27a00 - 0x27c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x27a00:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r29 = r29 + -56;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    r19 = r4 + r0;
+                    r18 = r5 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27b18;
+                        continue;
+                    }
+                    r17 = 7 << 16;
+                    r17 = r17 + 16880;
+                    r20 = readPages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27b4c;
+                        continue;
+                    }
+                    r2 = readPages[(r17+28)>>>12][((r17+28)>>>2)&0x3ff];
+                    r4 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r2 = r2 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27a6c;
+                        continue;
+                    }
+                    r21 = r4 - r20;
+                    if(r21 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27b58;
+                        continue;
+                    }
+                case 0x27a6c:
+                    r4 = r19 + r4;
+                    r2 = 2 << 16;
+                    r4 = r4 & 65535;
+                    writePages[(r17+28)>>>12][((r17+28)>>>2)&0x3ff] = r18;
+                    r2 = r2 + 22528;
+                    r18 = r18 & 1;
+                    writePages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff] = r4;
+                    writePages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff] = r4;
+                    writePages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff] = r2;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27c50;
+                        run_27c00(); return;
+                    }
+                case 0x27a98:
+                    r2 = readPages[(r17+32)>>>12][((r17+32)>>>2)&0x3ff];
+                    r7 = r4 + 1;
+                    r5 = r4 + r0;
+                case 0x27aa4:
+                    writePages[(r17+40)>>>12][((r17+40)>>>2)&0x3ff] = r7;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r5 < r3 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27ad8;
+                        continue;
+                    }
+                case 0x27abc:
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r5 < r3 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27abc;
+                        continue;
+                    }
+                case 0x27ad8:
+                    r4 = 7 << 16;
+                    r4 = r4 + 16912;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27d00;
+                        run_27c00(); return;
+                    }
+                    r3 = r3 + -1;
+                    writePages[(r17+24)>>>12][((r17+24)>>>2)&0x3ff] = r3;
+                case 0x27af0:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r21 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r20 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x27b18:
+                    r2 = 7 << 16;
+                    r2 = r2 + 16880;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    writePages[(r2+28)>>>12][((r2+28)>>>2)&0x3ff] = r5;
+                    r19 = r4 + r3;
+                    r19 = r19 & 65535;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r19;
+                    writePages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff] = r19;
+                    r2 = 2 << 16;
+                    r2 = r2 + 22528;
+                    writePages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x27af0;
+                    continue;
+                case 0x27b4c:
+                    r4 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x27a6c;
+                    continue;
+                case 0x27b58:
+                    r4 = r0 + 16;
+                    r16 = readPages[(r17+32)>>>12][((r17+32)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x27b68;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x27b68:
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r20;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r21;
+                    writePages[(r17+40)>>>12][((r17+40)>>>2)&0x3ff] = r20;
+                    r3 = r21 + 1;
+                    r7 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r17+44)>>>12][((r17+44)>>>2)&0x3ff] = r3;
+                case 0x27b80:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r6 = r3 < r7 ? 1 : 0;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27bb4;
+                        continue;
+                    }
+                    if(r3 != r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27bc0;
+                        continue;
+                    }
+                    r6 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r3 = r6 < r3 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27bc0;
+                        continue;
+                    }
+                case 0x27bb4:
+                    r16 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x27b80;
+                    continue;
+                case 0x27bc0:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r16;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27c14;
+                        run_27c00(); return;
+                    }
+                    r2 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r7 = readPages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                case 0x27c00:
+                    pc=0x27c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_27c00() throws ExecutionException { /* 0x27c00 - 0x27e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x27c00:
+                    r4 = r4 + -1800;
+                    r5 = r21 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x27c14;
+                    pc=0x3fc00;
+                    run_3fc00(); return;
+                case 0x27c14:
+                    r4 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r2 = 2 << 16;
+                    r4 = r19 + r4;
+                    r3 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r4 = r4 & 65535;
+                    r2 = r2 + 22528;
+                    writePages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff] = r4;
+                    writePages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff] = r4;
+                    writePages[(r17+28)>>>12][((r17+28)>>>2)&0x3ff] = r18;
+                    writePages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27af0;
+                        run_27a00(); return;
+                    }
+                    r18 = r18 & 1;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27a98;
+                        run_27a00(); return;
+                    }
+                case 0x27c50:
+                    r2 = readPages[(r17+32)>>>12][((r17+32)>>>2)&0x3ff];
+                    r7 = r4 + 1;
+                    r3 = r0 + 1;
+                    writePages[(r17+40)>>>12][((r17+40)>>>2)&0x3ff] = r7;
+                    writePages[(r17+44)>>>12][((r17+44)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = r4 < r3 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27cd0;
+                        continue;
+                    }
+                    r5 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r3 = r3 + r5;
+                    r3 = r4 < r3 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27cdc;
+                        continue;
+                    }
+                    r3 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x27cb4;
+                    continue;
+                case 0x27c9c:
+                    r6 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r5 = r5 + r6;
+                    r5 = r4 < r5 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27cdc;
+                        continue;
+                    }
+                case 0x27cb4:
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r6 = r4 < r5 ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27c9c;
+                        continue;
+                    }
+                case 0x27cd0:
+                    r5 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x27aa4;
+                    run_27a00(); return;
+                case 0x27cdc:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1736;
+                    /* Next insn is delay slot */ 
+                    r31=0x27cec;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x27cec:
+                    r5 = readPages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff];
+                    r2 = readPages[(r17+32)>>>12][((r17+32)>>>2)&0x3ff];
+                    r7 = r5 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x27aa4;
+                    run_27a00(); return;
+                case 0x27d00:
+                    r2 = r0 | 65535;
+                    writePages[(r17+24)>>>12][((r17+24)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x27af0;
+                    run_27a00(); return;
+                case 0x27e00:
+                    pc=0x27e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_27e00() throws ExecutionException { /* 0x27e00 - 0x28000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x27e00:
+                    r2 = 7 << 16;
+                    r29 = r29 + -40;
+                    r2 = r2 + 30664;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r19 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r16 = 7 << 16;
+                    r16 = r16 + 16880;
+                    r3 = r3 | 16;
+                    r18 = r0 + 1;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                    r17 = r5 + r0;
+                    r19 = r4 - r19;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r4;
+                    writePages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    r31=0x27e54;
+                    pc=0x27800;
+                    run_27800(); return;
+                case 0x27e54:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r19 = r19 & 65535;
+                    r3 = r19 + r2;
+                    r2 = 2 << 16;
+                    r2 = r2 + 22528;
+                    writePages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r3 = r3 & 65535;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r3;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r3;
+                    writePages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff] = r17;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27eec;
+                        continue;
+                    }
+                    r17 = r17 & 1;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27f0c;
+                        continue;
+                    }
+                    r2 = readPages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff];
+                    r7 = r3 + 1;
+                    r5 = r3 + r0;
+                case 0x27ea0:
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r7;
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r5 < r3 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27ed4;
+                        continue;
+                    }
+                case 0x27eb8:
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = r5 < r3 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27eb8;
+                        continue;
+                    }
+                case 0x27ed4:
+                    r4 = 7 << 16;
+                    r4 = r4 + 16912;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27fb4;
+                        continue;
+                    }
+                    r3 = r3 + -1;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r3;
+                case 0x27eec:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x27f0c:
+                    r2 = readPages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff];
+                    r7 = r3 + 1;
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r7;
+                    r4 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r16+44)>>>12][((r16+44)>>>2)&0x3ff] = r18;
+                    r5 = r3 < r4 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27f84;
+                        continue;
+                    }
+                    r5 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r4 + r5;
+                    r4 = r3 < r4 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27f90;
+                        continue;
+                    }
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x27f68;
+                    continue;
+                case 0x27f50:
+                    r6 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r5 = r5 + r6;
+                    r5 = r3 < r5 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27f90;
+                        continue;
+                    }
+                case 0x27f68:
+                    r4 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r6 = r3 < r5 ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x27f50;
+                        continue;
+                    }
+                case 0x27f84:
+                    r5 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x27ea0;
+                    continue;
+                case 0x27f90:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1736;
+                    /* Next insn is delay slot */ 
+                    r31=0x27fa0;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x27fa0:
+                    r5 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r2 = readPages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff];
+                    r7 = r5 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x27ea0;
+                    continue;
+                case 0x27fb4:
+                    r2 = r0 | 65535;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x27eec;
+                    continue;
+                case 0x28000:
+                    pc=0x28000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_28000() throws ExecutionException { /* 0x28000 - 0x28200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x28000:
+                    r5 = 7 << 16;
+                    r29 = r29 + -24;
+                    r5 = r5 + 30672;
+                    r6 = r0 + 24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x2801c;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2801c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x28200:
+                    pc=0x28200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_28200() throws ExecutionException { /* 0x28200 - 0x28400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x28200:
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+30696)>>>12][((r2+30696)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x28400:
+                    pc=0x28400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_28400() throws ExecutionException { /* 0x28400 - 0x28600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x28400:
+                    r2 = 7 << 16;
+                    r2 = r2 + 30664;
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = readPages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff];
+                    writePages[(r2+32)>>>12][((r2+32)>>>2)&0x3ff] = r0;
+                    r3 = r4 + r3;
+                    r3 = r3 & 65535;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x28600:
+                    pc=0x28600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_28600() throws ExecutionException { /* 0x28600 - 0x28800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x28600:
+                    r4 = 7 << 16;
+                    r29 = r29 + -24;
+                    r4 = r4 + -1668;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x28618;
+                    pc=0x3e000;
+                    run_3e000(); return;
+                case 0x28618:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x28664;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r2 + r0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x28634;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x28634:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + 47;
+                    /* Next insn is delay slot */ 
+                    r31=0x28644;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x28644:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x28654;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x28654:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x28660;
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x28660:
+                    writePages[(r28+-30676)>>>12][((r28+-30676)>>>2)&0x3ff] = r2;
+                case 0x28664:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x28800:
+                    pc=0x28800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_28800() throws ExecutionException { /* 0x28800 - 0x28a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x28800:
+                    r4 = 7 << 16;
+                    r29 = r29 + -24;
+                    r4 = r4 + -732;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x28818;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x28818:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x28a00:
+                    pc=0x28a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_28a00() throws ExecutionException { /* 0x28a00 - 0x28c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x28a00:
+                    r4 = 7 << 16;
+                    r29 = r29 + -24;
+                    r4 = r4 + -1660;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x28a18;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x28a18:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x28c00:
+                    pc=0x28c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_28c00() throws ExecutionException { /* 0x28c00 - 0x28e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x28c00:
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x28c10;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x28c10:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = r0 + 8;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 3;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x28e00:
+                    pc=0x28e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_28e00() throws ExecutionException { /* 0x28e00 - 0x29000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x28e00:
+                    r3 = r4 + r0;
+                    r4 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    r29 = r29 + -112;
+                    writePages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff] = r21;
+                    writePages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff] = r20;
+                    writePages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff] = r19;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r18;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r17;
+                    writePages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff] = r31;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r16;
+                    r21 = r5 + r0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r0;
+                    r5 = r3 + r0;
+                    r20 = 7 << 16;
+                    r19 = 7 << 16;
+                    r17 = 7 << 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x28e48;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x28e48:
+                    r20 = r20 + -1576;
+                    r19 = r19 + -1588;
+                    r18 = 7 << 16;
+                    r17 = r17 + -1616;
+                    /* Next insn is delay slot */ 
+                    pc=0x28ea0;
+                    continue;
+                case 0x28e60:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29048;
+                        run_29000(); return;
+                    }
+                    r7 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r6 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r4 = r29 + 16;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x28e80;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x28e80:
+                    r4 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x28e90;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x28e90:
+                    /* Next insn is delay slot */ 
+                    r31=0x28e98;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x28e98:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x28f14;
+                        continue;
+                    }
+                case 0x28ea0:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r16 = tmp;
+                    r2 = r0 + 34;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x28f44;
+                        continue;
+                    }
+                    r4 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    r31=0x28ebc;
+                    pc=0x16400;
+                    run_16400(); return;
+                case 0x28ebc:
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r3 = r2 & 256;
+                    r2 = r2 & 16;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x28e60;
+                        continue;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29030;
+                        run_29000(); return;
+                    }
+                    r6 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r4 = r29 + 16;
+                    r5 = r19 + r0;
+                    r7 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x28ef4;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x28ef4:
+                    r4 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x28f04;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x28f04:
+                    /* Next insn is delay slot */ 
+                    r31=0x28f0c;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x28f0c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x28ea0;
+                        continue;
+                    }
+                case 0x28f14:
+                    r4 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x28f24;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x28f24:
+                    r2 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r21;
+                    r31=0x28f38;
+                    return;
+                case 0x28f38:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x29008;
+                    run_29000(); return;
+                case 0x28f44:
+                    /* Next insn is delay slot */ 
+                    r31=0x28f4c;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x28f4c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29004;
+                        run_29000(); return;
+                    }
+                    if(r3 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29060;
+                        run_29000(); return;
+                    }
+                    r16 = r0 + 34;
+                    /* Next insn is delay slot */ 
+                    pc=0x28fa8;
+                    continue;
+                case 0x28f70:
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = r2 + 1;
+                    r2 = r5 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r6;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x28f8c;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x28f8c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29004;
+                        run_29000(); return;
+                    }
+                case 0x28f9c:
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29060;
+                        run_29000(); return;
+                    }
+                    r3 = r2 + r0;
+                case 0x28fa8:
+                    r4 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r2 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x28f70;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x28fcc;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x28fcc:
+                    r4 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = r2 + 1;
+                    r2 = r5 + r2;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r6;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x28ff4;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x28ff4:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x28f9c;
+                        continue;
+                    }
+                case 0x29000:
+                    pc=0x29000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_29000() throws ExecutionException { /* 0x29000 - 0x29200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x29000:
+                case 0x29004:
+                    r2 = r0 + 3;
+                case 0x29008:
+                    r31 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    r21 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r20 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    r19 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r18 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r17 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r16 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r29 = r29 + 112;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x29030:
+                    r4 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    r5 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x29040;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x29040:
+                    /* Next insn is delay slot */ 
+                    pc=0x28e90;
+                    run_28e00(); return;
+                case 0x29048:
+                    r4 = readPages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff];
+                    r5 = r18 + -1608;
+                    /* Next insn is delay slot */ 
+                    r31=0x29058;
+                    pc=0x17e00;
+                    run_17e00(); return;
+                case 0x29058:
+                    /* Next insn is delay slot */ 
+                    pc=0x28e90;
+                    run_28e00(); return;
+                case 0x29060:
+                    /* Next insn is delay slot */ 
+                    r31=0x29068;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x29068:
+                    /* Next insn is delay slot */ 
+                    pc=0x28e90;
+                    run_28e00(); return;
+                case 0x29200:
+                    pc=0x29200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_29200() throws ExecutionException { /* 0x29200 - 0x29400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x29200:
+                    r4 = 7 << 16;
+                    r5 = 2 << 16;
+                    r4 = r4 + -1560;
+                    r5 = r5 + -19968;
+                    /* Next insn is delay slot */ 
+                    pc=0x28e00;
+                    run_28e00(); return;
+                case 0x29400:
+                    pc=0x29400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_29400() throws ExecutionException { /* 0x29400 - 0x29600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x29400:
+                    r4 = 7 << 16;
+                    r5 = 2 << 16;
+                    r4 = r4 + -1548;
+                    r5 = r5 + -20480;
+                    /* Next insn is delay slot */ 
+                    pc=0x28e00;
+                    run_28e00(); return;
+                case 0x29600:
+                    pc=0x29600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_29600() throws ExecutionException { /* 0x29600 - 0x29800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x29600:
+                    r4 = 7 << 16;
+                    r5 = 2 << 16;
+                    r4 = r4 + -1536;
+                    r5 = r5 + -21504;
+                    /* Next insn is delay slot */ 
+                    pc=0x28e00;
+                    run_28e00(); return;
+                case 0x29800:
+                    pc=0x29800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_29800() throws ExecutionException { /* 0x29800 - 0x29a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x29800:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29870;
+                        continue;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 123;
+                    r16 = r0 + 123;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29844;
+                        continue;
+                    }
+                case 0x2982c:
+                    /* Next insn is delay slot */ 
+                    r31=0x29834;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x29834:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2982c;
+                        continue;
+                    }
+                case 0x29844:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x29850;
+                    pc=0x1d400;
+                    run_1d400(); return;
+                case 0x29850:
+                    /* Next insn is delay slot */ 
+                    r31=0x29858;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x29858:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x29870:
+                    /* Next insn is delay slot */ 
+                    r31=0x29878;
+                    pc=0x20600;
+                    run_20600(); return;
+                case 0x29878:
+                    /* Next insn is delay slot */ 
+                    r31=0x29880;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x29880:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x29a00:
+                    pc=0x29a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_29a00() throws ExecutionException { /* 0x29a00 - 0x29c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x29a00:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r29 = r29 + -56;
+                    r2 = r0 + 32;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29ae0;
+                        continue;
+                    }
+                case 0x29a18:
+                    r4 = r29 + 16;
+                    r5 = r0 + 123;
+                    /* Next insn is delay slot */ 
+                    r31=0x29a28;
+                    pc=0x19600;
+                    run_19600(); return;
+                case 0x29a28:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 123;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29a48;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6860;
+                    /* Next insn is delay slot */ 
+                    r31=0x29a48;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x29a48:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x29a64;
+                    pc=0x1d400;
+                    run_1d400(); return;
+                case 0x29a64:
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x29a70;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x29a70:
+                    r3 = r0 + 32;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29ad0;
+                        continue;
+                    }
+                case 0x29a7c:
+                    r5 = r0 + r0;
+                    r4 = r29 + 36;
+                    /* Next insn is delay slot */ 
+                    r31=0x29a8c;
+                    pc=0x19600;
+                    run_19600(); return;
+                case 0x29a8c:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x29a98;
+                    pc=0x19800;
+                    run_19800(); return;
+                case 0x29a98:
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x29aa4;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x29aa4:
+                    r4 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x29ab0;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x29ab0:
+                    r4 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x29abc;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x29abc:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x29ad0:
+                    /* Next insn is delay slot */ 
+                    r31=0x29ad8;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x29ad8:
+                    /* Next insn is delay slot */ 
+                    pc=0x29a7c;
+                    continue;
+                case 0x29ae0:
+                    /* Next insn is delay slot */ 
+                    r31=0x29ae8;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x29ae8:
+                    /* Next insn is delay slot */ 
+                    pc=0x29a18;
+                    continue;
+                case 0x29c00:
+                    pc=0x29c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_29c00() throws ExecutionException { /* 0x29c00 - 0x29e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x29c00:
+                    r29 = r29 + -88;
+                    r4 = r29 + 72;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x29c14;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x29c14:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29c30;
+                        continue;
+                    }
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x29c30:
+                    /* Next insn is delay slot */ 
+                    r31=0x29c38;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x29c38:
+                    r4 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x29c48;
+                    pc=0x2f400;
+                    run_2f400(); return;
+                case 0x29c48:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x29c54;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x29c54:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29db0;
+                        continue;
+                    }
+                    r4 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    r31=0x29c68;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x29c68:
+                    r2 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x29c7c;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x29c7c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29d04;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-32336)>>>12][((r28+-32336)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29df8;
+                        continue;
+                    }
+                case 0x29c94:
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r4 = r29 + 48;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x29ca8;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x29ca8:
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30740)>>>12][((r28+-30740)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29ce4;
+                        continue;
+                    }
+                    r3 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r4 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29ce4;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -1500;
+                    /* Next insn is delay slot */ 
+                    r31=0x29ce0;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x29ce0:
+                    r2 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                case 0x29ce4:
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29d34;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x29d38;
+                    continue;
+                case 0x29d04:
+                    r2 = r0 + 1;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-32336)>>>12][((r28+-32336)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29e10;
+                        run_29e00(); return;
+                    }
+                case 0x29d1c:
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29dd4;
+                        continue;
+                    }
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                case 0x29d34:
+                    r2 = r0 + 1;
+                case 0x29d38:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 123;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x29d5c;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6860;
+                    /* Next insn is delay slot */ 
+                    r31=0x29d5c;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x29d5c:
+                    r2 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    r2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x29d78;
+                    pc=0x1d400;
+                    run_1d400(); return;
+                case 0x29d78:
+                    r4 = r29 + 16;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x29d88;
+                    pc=0x19400;
+                    run_19400(); return;
+                case 0x29d88:
+                    r4 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x29d94;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x29d94:
+                    /* Next insn is delay slot */ 
+                    r31=0x29d9c;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x29d9c:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x29db0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x29dc0;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x29dc0:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x29dd4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1404;
+                    /* Next insn is delay slot */ 
+                    r31=0x29de4;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x29de4:
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x29d34;
+                    continue;
+                case 0x29df8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1528;
+                case 0x29e00:
+                    pc=0x29e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_29e00() throws ExecutionException { /* 0x29e00 - 0x2a000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x29e00:
+                    /* Next insn is delay slot */ 
+                    r31=0x29e08;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x29e08:
+                    /* Next insn is delay slot */ 
+                    pc=0x29c94;
+                    run_29c00(); return;
+                case 0x29e10:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1432;
+                    /* Next insn is delay slot */ 
+                    r31=0x29e20;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x29e20:
+                    /* Next insn is delay slot */ 
+                    pc=0x29d1c;
+                    run_29c00(); return;
+                case 0x2a000:
+                    pc=0x2a000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2a000() throws ExecutionException { /* 0x2a000 - 0x2a200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2a000:
+                    r29 = r29 + -32;
+                    r4 = r29 + 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a018;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x2a018:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a038;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                case 0x2a024:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a038:
+                    r5 = 7 << 16;
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = r29 + 20;
+                    r5 = r5 + 16944;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a054;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x2a054:
+                    r2 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a0d4;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a0bc;
+                        continue;
+                    }
+                case 0x2a074:
+                    r16 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r16 = r16 >>> 4;
+                    r16 = r16 & 1;
+                    r16 = r16 ^ 1;
+                case 0x2a088:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 32;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a0f8;
+                        continue;
+                    }
+                case 0x2a098:
+                    r2 = r0 + 123;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a0e0;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r16 << 1;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a0bc:
+                    r3 = readPages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x2a074;
+                    continue;
+                case 0x2a0d4:
+                    r16 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2a088;
+                    continue;
+                case 0x2a0e0:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a0ec;
+                    pc=0x19a00;
+                    run_19a00(); return;
+                case 0x2a0ec:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2a024;
+                    continue;
+                case 0x2a0f8:
+                    /* Next insn is delay slot */ 
+                    r31=0x2a100;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2a100:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x2a098;
+                    continue;
+                case 0x2a200:
+                    pc=0x2a200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2a200() throws ExecutionException { /* 0x2a200 - 0x2a400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2a200:
+                    r29 = r29 + -48;
+                    r4 = r29 + 16;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a214;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x2a214:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 123;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a234;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6860;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a234;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x2a234:
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = ((r0 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a248;
+                    pc=0x19a00;
+                    run_19a00(); return;
+                case 0x2a248:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a400:
+                    pc=0x2a400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2a400() throws ExecutionException { /* 0x2a400 - 0x2a600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2a400:
+                    r29 = r29 + -64;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r16;
+                    r16 = 7 << 16;
+                    r16 = r16 + 30664;
+                    r4 = r29 + 16;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r19;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r18;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r17;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    r18 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2a430;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x2a430:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r2 | 16;
+                    r19 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a450;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2a450:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a494;
+                        continue;
+                    }
+                    r17 = r17 - r19;
+                    r19 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r17 = r19 - r17;
+                    r17 = r17 & 65535;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r17;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r18;
+                    r19 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r18 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r17 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r16 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a494:
+                    r4 = 7 << 16;
+                    r4 = r4 + -732;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a4a4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2a4a4:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r19 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r18 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r17 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r16 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a600:
+                    pc=0x2a600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2a600() throws ExecutionException { /* 0x2a600 - 0x2a800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2a600:
+                    r29 = r29 + -40;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r4 = r29 + 16;
+                    r5 = r16 + r0;
+                    r6 = r0 + 16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a624;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2a624:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = 7 << 16;
+                    r2 = r2 + -7236;
+                    r2 = r3 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a6e4;
+                        continue;
+                    }
+                    r6 = 7 << 16;
+                    r4 = r16 + r0;
+                    r7 = r0 + r0;
+                    r6 = r6 + 6068;
+                case 0x2a658:
+                    r5 = 7 << 16;
+                    r5 = r5 + -1380;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a668;
+                    pc=0x2e400;
+                    run_2e400(); return;
+                case 0x2a668:
+                    /* Next insn is delay slot */ 
+                    r31=0x2a670;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2a670:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a6ac;
+                        continue;
+                    }
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a684;
+                    pc=0x2e600;
+                    run_2e600(); return;
+                case 0x2a684:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r3 = r3 + 12764;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a6ac:
+                    r4 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2a6b8;
+                    pc=0x2e600;
+                    run_2e600(); return;
+                case 0x2a6b8:
+                    r4 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a6cc;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2a6cc:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a6e4:
+                    /* Next insn is delay slot */ 
+                    r31=0x2a6ec;
+                    pc=0x1ec00;
+                    run_1ec00(); return;
+                case 0x2a6ec:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2a6f8;
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x2a6f8:
+                    r6 = r2 + r0;
+                    r4 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2a658;
+                    continue;
+                case 0x2a800:
+                    pc=0x2a800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2a800() throws ExecutionException { /* 0x2a800 - 0x2aa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2a800:
+                    r29 = r29 + -64;
+                    r4 = r29 + 40;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r17;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a81c;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x2a81c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a840;
+                        continue;
+                    }
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r17 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r16 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a840:
+                    /* Next insn is delay slot */ 
+                    r31=0x2a848;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x2a848:
+                    r4 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r5 = r2 + r0;
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a85c;
+                    pc=0x2f400;
+                    run_2f400(); return;
+                case 0x2a85c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r17 = r2 + r0;
+                    r2 = r0 + 61;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a89c;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a880;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2a880:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r17 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r16 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a89c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2a8a4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2a8a4:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a8b0;
+                    pc=0x16400;
+                    run_16400(); return;
+                case 0x2a8b0:
+                    r3 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    r2 = r0 + -16;
+                    r3 = r3 & r2;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2a8f8;
+                        continue;
+                    }
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r3;
+                case 0x2a8c8:
+                    r4 = r17 + r0;
+                    r5 = r29 + 16;
+                    r6 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x2a8dc;
+                    pc=0x2f600;
+                    run_2f600(); return;
+                case 0x2a8dc:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r17 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r16 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2a8f8:
+                    r3 = r16 | r3;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r3 & r2;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x2a8c8;
+                    continue;
+                case 0x2aa00:
+                    pc=0x2aa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2aa00() throws ExecutionException { /* 0x2aa00 - 0x2ac00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2aa00:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -24;
+                    r3 = r0 + 32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2aa60;
+                        continue;
+                    }
+                case 0x2aa18:
+                    r3 = r0 + 123;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2aa44;
+                        continue;
+                    }
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x2aa30;
+                    pc=0x31e00;
+                    run_31e00(); return;
+                case 0x2aa30:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2aa44:
+                    /* Next insn is delay slot */ 
+                    r31=0x2aa4c;
+                    pc=0x31c00;
+                    run_31c00(); return;
+                case 0x2aa4c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2aa60:
+                    /* Next insn is delay slot */ 
+                    r31=0x2aa68;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2aa68:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x2aa18;
+                    continue;
+                case 0x2ac00:
+                    pc=0x2ac00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2ac00() throws ExecutionException { /* 0x2ac00 - 0x2ae00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2ac00:
+                    r2 = 7 << 16;
+                    r29 = r29 + -32;
+                    r4 = r2 + 30704;
+                    r5 = r0 + 1;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = readPages[(r2+30704)>>>12][((r2+30704)>>>2)&0x3ff];
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ac2c;
+                    pc=0x17200;
+                    run_17200(); return;
+                case 0x2ac2c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2ac34;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2ac34:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ac4c;
+                        continue;
+                    }
+                    r4 = r16 + 30704;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ac4c;
+                    pc=0x17200;
+                    run_17200(); return;
+                case 0x2ac4c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ae00:
+                    pc=0x2ae00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2ae00() throws ExecutionException { /* 0x2ae00 - 0x2b000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2ae00:
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = 7 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r17 = readPages[(r16+30664)>>>12][((r16+30664)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2ae20;
+                    pc=0x1f400;
+                    run_1f400(); return;
+                case 0x2ae20:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ae58;
+                        continue;
+                    }
+                case 0x2ae28:
+                    /* Next insn is delay slot */ 
+                    r31=0x2ae30;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2ae30:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ae3c;
+                        continue;
+                    }
+                    writePages[(r16+30664)>>>12][((r16+30664)>>>2)&0x3ff] = r17;
+                case 0x2ae3c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ae58:
+                    /* Next insn is delay slot */ 
+                    r31=0x2ae60;
+                    pc=0x17000;
+                    run_17000(); return;
+                case 0x2ae60:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ae74;
+                        continue;
+                    }
+                    writePages[(r16+30664)>>>12][((r16+30664)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x2ae28;
+                    continue;
+                case 0x2ae74:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1372;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ae84;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2ae84:
+                    /* Next insn is delay slot */ 
+                    pc=0x2ae28;
+                    continue;
+                case 0x2b000:
+                    pc=0x2b000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2b000() throws ExecutionException { /* 0x2b000 - 0x2b200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2b000:
+                    r29 = r29 + -48;
+                    r4 = r29 + 16;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b018;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x2b018:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b020;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2b020:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b080;
+                        continue;
+                    }
+                    r16 = r0 + r0;
+                case 0x2b02c:
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r3 = r2 + -1;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b068;
+                        continue;
+                    }
+                case 0x2b044:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b050;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2b050:
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = r3 + -1;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r5;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b044;
+                        continue;
+                    }
+                case 0x2b068:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2b080:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b088;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2b088:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2b02c;
+                    continue;
+                case 0x2b200:
+                    pc=0x2b200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2b200() throws ExecutionException { /* 0x2b200 - 0x2b400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2b200:
+                    r29 = r29 + -48;
+                    r2 = r0 + -1;
+                    r4 = r0 + 1;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r17;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b228;
+                    pc=0x1fc00;
+                    run_1fc00(); return;
+                case 0x2b228:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b24c;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                case 0x2b234:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r17 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r16 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2b24c:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = r5 + 12832;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b264;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x2b264:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b498;
+                        run_2b400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2b278;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2b278:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b438;
+                        run_2b400(); return;
+                    }
+                case 0x2b280:
+                    r4 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    if(r4 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b2b0;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30576)>>>12][((r28+-30576)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b3a0;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30580)>>>12][((r28+-30580)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b3a0;
+                        continue;
+                    }
+                case 0x2b2b0:
+                    r5 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b2c4;
+                    pc=0x3d400;
+                    run_3d400(); return;
+                case 0x2b2c4:
+                    r2 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b3a8;
+                        continue;
+                    }
+                    r17 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2b31c;
+                    continue;
+                case 0x2b2e0:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                case 0x2b2f4:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2b304;
+                    return;
+                case 0x2b304:
+                    r2 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b3a8;
+                        continue;
+                    }
+                case 0x2b31c:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b2e0;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b344;
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x2b344:
+                    r4 = r2 + r0;
+                    if(r2 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b2f4;
+                        continue;
+                    }
+                    r2 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b3a8;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -1328;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b370;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x2b370:
+                    r2 = readPages[(r28+-30572)>>>12][((r28+-30572)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x2b380;
+                    return;
+                case 0x2b380:
+                    r2 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b370;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x2b3a8;
+                    continue;
+                case 0x2b3a0:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b3a8;
+                    pc=0x25c00;
+                    run_25c00(); return;
+                case 0x2b3a8:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b3b4;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x2b3b4:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b41c;
+                        run_2b400(); return;
+                    }
+                    r2 = readPages[(r28+-30736)>>>12][((r28+-30736)>>>2)&0x3ff];
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b41c;
+                        run_2b400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2b3e0;
+                    pc=0x28200;
+                    run_28200(); return;
+                case 0x2b3e0:
+                    r7 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r4 = r4 + -1304;
+                    r5 = r2 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b400;
+                    pc=0x3fc00;
+                    run_3fc00(); return;
+                case 0x2b400:
+                    pc=0x2b400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2b400() throws ExecutionException { /* 0x2b400 - 0x2b600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2b400:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r17 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r16 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2b41c:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r17 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r16 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2b438:
+                    r4 = r29 + 28;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b444;
+                    pc=0x15a00;
+                    run_15a00(); return;
+                case 0x2b444:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b45c;
+                        continue;
+                    }
+                    r2 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b480;
+                        continue;
+                    }
+                case 0x2b45c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b464;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2b464:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b280;
+                        run_2b200(); return;
+                    }
+                    r4 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b478;
+                    pc=0x15a00;
+                    run_15a00(); return;
+                case 0x2b478:
+                    /* Next insn is delay slot */ 
+                    pc=0x2b280;
+                    run_2b200(); return;
+                case 0x2b480:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1352;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b490;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x2b490:
+                    /* Next insn is delay slot */ 
+                    pc=0x2b45c;
+                    continue;
+                case 0x2b498:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6824;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b4a8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2b4a8:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2b234;
+                    run_2b200(); return;
+                case 0x2b600:
+                    pc=0x2b600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2b600() throws ExecutionException { /* 0x2b600 - 0x2b800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2b600:
+                    r2 = 7 << 16;
+                    r29 = r29 + -32;
+                    r2 = r2 + 12720;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = readPages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r2;
+                    r16 = r0 + 34;
+                    /* Next insn is delay slot */ 
+                    pc=0x2b650;
+                    continue;
+                case 0x2b62c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b634;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2b634:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b640;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2b640:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b648;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2b648:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b6e0;
+                        continue;
+                    }
+                case 0x2b650:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b62c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2b668;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2b668:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b6ac;
+                        continue;
+                    }
+                case 0x2b678:
+                    if(r4 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b6c8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2b688;
+                    pc=0x18c00;
+                    run_18c00(); return;
+                case 0x2b688:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b694;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2b694:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b69c;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2b69c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b678;
+                        continue;
+                    }
+                case 0x2b6ac:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2b6c8:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b6d0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2b6d0:
+                    /* Next insn is delay slot */ 
+                    r31=0x2b6d8;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2b6d8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b650;
+                        continue;
+                    }
+                case 0x2b6e0:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r17;
+                    r2 = r0 + 1;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2b800:
+                    pc=0x2b800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2b800() throws ExecutionException { /* 0x2b800 - 0x2ba00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2b800:
+                    r2 = readPages[(r28+-32764)>>>12][((r28+-32764)>>>2)&0x3ff];
+                    r29 = r29 + -64;
+                    r2 = r2 + -1;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r30;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r19;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r18;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r17;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    r30 = r29 + r0;
+                    writePages[(r28+-32764)>>>12][((r28+-32764)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b934;
+                        continue;
+                    }
+                case 0x2b834:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b840;
+                    pc=0x1fc00;
+                    run_1fc00(); return;
+                case 0x2b840:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b874;
+                        continue;
+                    }
+                    r29 = r30 + r0;
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r19 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r18 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r17 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2b874:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = r5 + 12832;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b88c;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x2b88c:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2b94c;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r17 = r29 + r0;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r3 = r3 + 7;
+                    r3 = r3 >>> 3;
+                    r3 = r3 << 3;
+                    r29 = r29 - r3;
+                    r3 = r29 + 16;
+                    r4 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b8c8;
+                    pc=0x42e00;
+                    run_42e00(); return;
+                case 0x2b8c8:
+                    r3 = r2 + r0;
+                    r19 = readPages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff];
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r2 = r30 + 16;
+                    r4 = r16 + r0;
+                    r5 = r3 + r0;
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b8ec;
+                    pc=0x19c00;
+                    run_19c00(); return;
+                case 0x2b8ec:
+                    writePages[(r28+-32244)>>>12][((r28+-32244)>>>2)&0x3ff] = r19;
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r29 = r17 + r0;
+                case 0x2b8f8:
+                    r2 = readPages[(r28+-32764)>>>12][((r28+-32764)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r28+-32764)>>>12][((r28+-32764)>>>2)&0x3ff] = r2;
+                    r29 = r30 + r0;
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r19 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r18 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r17 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2b934:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1244;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b944;
+                    pc=0x1b200;
+                    run_1b200(); return;
+                case 0x2b944:
+                    /* Next insn is delay slot */ 
+                    pc=0x2b834;
+                    continue;
+                case 0x2b94c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6824;
+                    /* Next insn is delay slot */ 
+                    r31=0x2b95c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2b95c:
+                    /* Next insn is delay slot */ 
+                    pc=0x2b8f8;
+                    continue;
+                case 0x2ba00:
+                    pc=0x2ba00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2ba00() throws ExecutionException { /* 0x2ba00 - 0x2bc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2ba00:
+                    r29 = r29 + -24;
+                    r4 = r0 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ba14;
+                    pc=0x1fc00;
+                    run_1fc00(); return;
+                case 0x2ba14:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ba60;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ba60;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30840)>>>12][((r28+-30840)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ba74;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -1204;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ba4c;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x2ba4c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ba60:
+                    r2 = r0 + r0;
+                case 0x2ba64:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ba74:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2ba80;
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x2ba80:
+                    writePages[(r28+-30840)>>>12][((r28+-30840)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2ba64;
+                    continue;
+                case 0x2bc00:
+                    pc=0x2bc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2bc00() throws ExecutionException { /* 0x2bc00 - 0x2be00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2bc00:
+                    r29 = r29 + -80;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r17;
+                    r17 = 7 << 16;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r16;
+                    r16 = r17 + 30664;
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r31;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r18;
+                    r2 = r2 & 16;
+                    r18 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bce4;
+                        continue;
+                    }
+                    r4 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    r31=0x2bc3c;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x2bc3c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2bc44;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2bc44:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bd34;
+                        continue;
+                    }
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2bc58;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x2bc58:
+                    /* Next insn is delay slot */ 
+                    r31=0x2bc60;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2bc60:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bd20;
+                        continue;
+                    }
+                case 0x2bc68:
+                    r2 = readPages[(r17+30664)>>>12][((r17+30664)>>>2)&0x3ff];
+                    addr=r2+8;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r17 = tmp;
+                case 0x2bc74:
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r16 = r18 + 1;
+                    r18 = r18 & r2;
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bc9c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x2bcc4;
+                    continue;
+                case 0x2bc98:
+                    r16 = r5 + r0;
+                case 0x2bc9c:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2bca8;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2bca8:
+                    r3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r5 = r16 + 1;
+                    r16 = r16 & r3;
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    if(r16 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bc98;
+                        continue;
+                    }
+                case 0x2bcc4:
+                    r31 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r18 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r17 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r16 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2bce4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6964;
+                    /* Next insn is delay slot */ 
+                    r31=0x2bcf4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2bcf4:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r31 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r2 = r2 | 16;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    r18 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r17 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r16 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2bd20:
+                    /* Next insn is delay slot */ 
+                    r31=0x2bd28;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2bd28:
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2bc74;
+                    continue;
+                case 0x2bd34:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x2bd44;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2bd44:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2bd50;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x2bd50:
+                    /* Next insn is delay slot */ 
+                    r31=0x2bd58;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2bd58:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bc68;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x2bd20;
+                    continue;
+                case 0x2be00:
+                    pc=0x2be00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2be00() throws ExecutionException { /* 0x2be00 - 0x2c000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2be00:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -288;
+                    r3 = r0 + 60;
+                    writePages[(r29+284)>>>12][((r29+284)>>>2)&0x3ff] = r31;
+                    writePages[(r29+280)>>>12][((r29+280)>>>2)&0x3ff] = r18;
+                    writePages[(r29+276)>>>12][((r29+276)>>>2)&0x3ff] = r17;
+                    writePages[(r29+272)>>>12][((r29+272)>>>2)&0x3ff] = r16;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2be88;
+                        continue;
+                    }
+                    r3 = r0 + 34;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2be88;
+                        continue;
+                    }
+                    r16 = readPages[(r28+-32344)>>>12][((r28+-32344)>>>2)&0x3ff];
+                    r17 = readPages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2be40;
+                    pc=0x1f400;
+                    run_1f400(); return;
+                case 0x2be40:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bf34;
+                        continue;
+                    }
+                case 0x2be48:
+                    r2 = r29 + 16;
+                    writePages[(r28+-32344)>>>12][((r28+-32344)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x2be58;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2be58:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2be64;
+                        continue;
+                    }
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r17;
+                case 0x2be64:
+                    r31 = readPages[(r29+284)>>>12][((r29+284)>>>2)&0x3ff];
+                    r18 = readPages[(r29+280)>>>12][((r29+280)>>>2)&0x3ff];
+                    r17 = readPages[(r29+276)>>>12][((r29+276)>>>2)&0x3ff];
+                    writePages[(r28+-32344)>>>12][((r28+-32344)>>>2)&0x3ff] = r16;
+                    r2 = r0 + 1;
+                    r16 = readPages[(r29+272)>>>12][((r29+272)>>>2)&0x3ff];
+                    r29 = r29 + 288;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2be88:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x2be94;
+                    pc=0x1fc00;
+                    run_1fc00(); return;
+                case 0x2be94:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bebc;
+                        continue;
+                    }
+                    r31 = readPages[(r29+284)>>>12][((r29+284)>>>2)&0x3ff];
+                    r18 = readPages[(r29+280)>>>12][((r29+280)>>>2)&0x3ff];
+                    r17 = readPages[(r29+276)>>>12][((r29+276)>>>2)&0x3ff];
+                    r16 = readPages[(r29+272)>>>12][((r29+272)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 288;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2bebc:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r16 = r29 + 16;
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r17 = readPages[(r28+-32344)>>>12][((r28+-32344)>>>2)&0x3ff];
+                    r18 = readPages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2bedc;
+                    pc=0x19000;
+                    run_19000(); return;
+                case 0x2bedc:
+                    r2 = 7 << 16;
+                    r2 = r2 + 12712;
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r2;
+                    writePages[(r28+-32344)>>>12][((r28+-32344)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2bef4;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2bef4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2bf50;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    r6 = r0 + 256;
+                    /* Next insn is delay slot */ 
+                    r31=0x2bf10;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2bf10:
+                    writePages[(r28+-32344)>>>12][((r28+-32344)>>>2)&0x3ff] = r17;
+                    r2 = r0 + 1;
+                case 0x2bf18:
+                    r31 = readPages[(r29+284)>>>12][((r29+284)>>>2)&0x3ff];
+                    r18 = readPages[(r29+280)>>>12][((r29+280)>>>2)&0x3ff];
+                    r17 = readPages[(r29+276)>>>12][((r29+276)>>>2)&0x3ff];
+                    r16 = readPages[(r29+272)>>>12][((r29+272)>>>2)&0x3ff];
+                    r29 = r29 + 288;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2bf34:
+                    /* Next insn is delay slot */ 
+                    r31=0x2bf3c;
+                    pc=0x19200;
+                    run_19200(); return;
+                case 0x2bf3c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2be48;
+                        continue;
+                    }
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x2be48;
+                    continue;
+                case 0x2bf50:
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r18;
+                    writePages[(r28+-32344)>>>12][((r28+-32344)>>>2)&0x3ff] = r17;
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2bf18;
+                    continue;
+                case 0x2c000:
+                    pc=0x2c000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2c000() throws ExecutionException { /* 0x2c000 - 0x2c200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2c000:
+                    r29 = r29 + -24;
+                    r4 = r0 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c014;
+                    pc=0x1fc00;
+                    run_1fc00(); return;
+                case 0x2c014:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c02c;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c040;
+                        continue;
+                    }
+                case 0x2c02c:
+                    r2 = r0 + r0;
+                case 0x2c030:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2c040:
+                    /* Next insn is delay slot */ 
+                    r31=0x2c048;
+                    pc=0x26c00;
+                    run_26c00(); return;
+                case 0x2c048:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c02c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2c058;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2c058:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c08c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2c068;
+                    pc=0x1f400;
+                    run_1f400(); return;
+                case 0x2c068:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c02c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2c078;
+                    pc=0x26800;
+                    run_26800(); return;
+                case 0x2c078:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c0b8;
+                        continue;
+                    }
+                case 0x2c080:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2c030;
+                    continue;
+                case 0x2c08c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2c094;
+                    pc=0x26a00;
+                    run_26a00(); return;
+                case 0x2c094:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c080;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -1164;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c0ac;
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x2c0ac:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2c030;
+                    continue;
+                case 0x2c0b8:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1100;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c0c8;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2c0c8:
+                    /* Next insn is delay slot */ 
+                    pc=0x2c02c;
+                    continue;
+                case 0x2c200:
+                    pc=0x2c200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2c200() throws ExecutionException { /* 0x2c200 - 0x2c400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2c200:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r29 = r29 + -48;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c228;
+                        continue;
+                    }
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2c228:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c234;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x2c234:
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r4 + 128;
+                    r2 = (r2&0xffffffffL) < (384&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c270;
+                        continue;
+                    }
+                case 0x2c24c:
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c25c;
+                    pc=0x26600;
+                    run_26600(); return;
+                case 0x2c25c:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = (r2&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2c270:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6936;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c280;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2c280:
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x2c24c;
+                    continue;
+                case 0x2c400:
+                    pc=0x2c400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2c400() throws ExecutionException { /* 0x2c400 - 0x2c600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2c400:
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                case 0x2c408:
+                    /* Next insn is delay slot */ 
+                    r31=0x2c410;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2c410:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c41c;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2c41c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2c424;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2c424:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c408;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2c600:
+                    pc=0x2c600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2c600() throws ExecutionException { /* 0x2c600 - 0x2c800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2c600:
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                case 0x2c608:
+                    /* Next insn is delay slot */ 
+                    r31=0x2c610;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2c610:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c61c;
+                    pc=0x26000;
+                    run_26000(); return;
+                case 0x2c61c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2c624;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2c624:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c608;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2c800:
+                    pc=0x2c800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2c800() throws ExecutionException { /* 0x2c800 - 0x2ca00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2c800:
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                case 0x2c808:
+                    /* Next insn is delay slot */ 
+                    r31=0x2c810;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2c810:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2c81c;
+                    pc=0x26200;
+                    run_26200(); return;
+                case 0x2c81c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2c824;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2c824:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2c808;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ca00:
+                    pc=0x2ca00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2ca00() throws ExecutionException { /* 0x2ca00 - 0x2cc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2ca00:
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                case 0x2ca08:
+                    /* Next insn is delay slot */ 
+                    r31=0x2ca10;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2ca10:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ca1c;
+                    pc=0x26400;
+                    run_26400(); return;
+                case 0x2ca1c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2ca24;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2ca24:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ca08;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2cc00:
+                    pc=0x2cc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2cc00() throws ExecutionException { /* 0x2cc00 - 0x2ce00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2cc00:
+                    r2 = 7 << 16;
+                    r29 = r29 + -32;
+                    r4 = r2 + 30700;
+                    r5 = r0 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = readPages[(r2+30700)>>>12][((r2+30700)>>>2)&0x3ff];
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2cc2c;
+                    pc=0x17200;
+                    run_17200(); return;
+                case 0x2cc2c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2cc34;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2cc34:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2cc4c;
+                        continue;
+                    }
+                    r4 = r16 + 30700;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2cc4c;
+                    pc=0x17200;
+                    run_17200(); return;
+                case 0x2cc4c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ce00:
+                    pc=0x2ce00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2ce00() throws ExecutionException { /* 0x2ce00 - 0x2d000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2ce00:
+                    r2 = 7 << 16;
+                    r29 = r29 + -32;
+                    r4 = r2 + 30700;
+                    r5 = r0 + 1;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = readPages[(r2+30700)>>>12][((r2+30700)>>>2)&0x3ff];
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ce2c;
+                    pc=0x17200;
+                    run_17200(); return;
+                case 0x2ce2c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2ce34;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2ce34:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ce4c;
+                        continue;
+                    }
+                    r4 = r16 + 30700;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ce4c;
+                    pc=0x17200;
+                    run_17200(); return;
+                case 0x2ce4c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d000:
+                    pc=0x2d000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2d000() throws ExecutionException { /* 0x2d000 - 0x2d200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2d000:
+                    r2 = 7 << 16;
+                    r29 = r29 + -32;
+                    r4 = r2 + 30704;
+                    r5 = r0 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = readPages[(r2+30704)>>>12][((r2+30704)>>>2)&0x3ff];
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d02c;
+                    pc=0x17200;
+                    run_17200(); return;
+                case 0x2d02c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d034;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2d034:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d04c;
+                        continue;
+                    }
+                    r4 = r16 + 30704;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d04c;
+                    pc=0x17200;
+                    run_17200(); return;
+                case 0x2d04c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d200:
+                    pc=0x2d200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2d200() throws ExecutionException { /* 0x2d200 - 0x2d400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2d200:
+                    r29 = r29 + -32;
+                    r4 = r29 + 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d218;
+                    pc=0x1e400;
+                    run_1e400(); return;
+                case 0x2d218:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d238;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                case 0x2d224:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d238:
+                    r5 = 7 << 16;
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = r29 + 20;
+                    r5 = r5 + 16944;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d254;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x2d254:
+                    r2 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d2d0;
+                        continue;
+                    }
+                    r3 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d2b8;
+                        continue;
+                    }
+                case 0x2d274:
+                    r16 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r16 = r16 >>> 4;
+                    r16 = r16 & 1;
+                case 0x2d284:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 32;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d2f4;
+                        continue;
+                    }
+                case 0x2d294:
+                    r2 = r0 + 123;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d2dc;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r16 << 1;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d2b8:
+                    r3 = readPages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x2d274;
+                    continue;
+                case 0x2d2d0:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2d284;
+                    continue;
+                case 0x2d2dc:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d2e8;
+                    pc=0x19a00;
+                    run_19a00(); return;
+                case 0x2d2e8:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2d224;
+                    continue;
+                case 0x2d2f4:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d2fc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2d2fc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x2d294;
+                    continue;
+                case 0x2d400:
+                    pc=0x2d400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2d400() throws ExecutionException { /* 0x2d400 - 0x2d600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2d400:
+                    r4 = 7 << 16;
+                    r29 = r29 + -40;
+                    r4 = r4 + -1076;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d41c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2d41c:
+                    r16 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r4 = r29 + 16;
+                    r5 = r16 + r0;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d434;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2d434:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = 7 << 16;
+                    r2 = r2 + -7236;
+                    r2 = r3 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d4f4;
+                        continue;
+                    }
+                    r6 = 7 << 16;
+                    r4 = r16 + r0;
+                    r7 = r0 + r0;
+                    r6 = r6 + 6068;
+                case 0x2d468:
+                    r5 = 7 << 16;
+                    r5 = r5 + -1380;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d478;
+                    pc=0x2e400;
+                    run_2e400(); return;
+                case 0x2d478:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d480;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x2d480:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d4bc;
+                        continue;
+                    }
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d494;
+                    pc=0x2e600;
+                    run_2e600(); return;
+                case 0x2d494:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r3 = r3 + 12764;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d4bc:
+                    r4 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2d4c8;
+                    pc=0x2e600;
+                    run_2e600(); return;
+                case 0x2d4c8:
+                    r4 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    r6 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d4dc;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2d4dc:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d4f4:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d4fc;
+                    pc=0x1ec00;
+                    run_1ec00(); return;
+                case 0x2d4fc:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x2d508;
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x2d508:
+                    r6 = r2 + r0;
+                    r4 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x2d468;
+                    continue;
+                case 0x2d600:
+                    pc=0x2d600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2d600() throws ExecutionException { /* 0x2d600 - 0x2d800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2d600:
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d61c;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2d61c:
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d628;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2d628:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d738;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 << 24;
+                    r2 = r2 + 12716;
+                    r18 = readPages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff];
+                    r17 = r17 >> 24;
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r2;
+                    r16 = r0 + 34;
+                    /* Next insn is delay slot */ 
+                    pc=0x2d678;
+                    continue;
+                case 0x2d654:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d65c;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2d65c:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d668;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2d668:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d670;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2d670:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d714;
+                        continue;
+                    }
+                case 0x2d678:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d654;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2d690;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2d690:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d6dc;
+                        continue;
+                    }
+                case 0x2d6a0:
+                    if(r4 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d6fc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2d6b0;
+                    pc=0x18c00;
+                    run_18c00(); return;
+                case 0x2d6b0:
+                    r4 = r2 ^ r17;
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d6c4;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2d6c4:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d6cc;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2d6cc:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d6a0;
+                        continue;
+                    }
+                case 0x2d6dc:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d6fc:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d704;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2d704:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d70c;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2d70c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d678;
+                        continue;
+                    }
+                case 0x2d714:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r18;
+                    r2 = r0 + 1;
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d738:
+                    r4 = 7 << 16;
+                    r4 = r4 + -6980;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d748;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2d748:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d800:
+                    pc=0x2d800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2d800() throws ExecutionException { /* 0x2d800 - 0x2da00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2d800:
+                    r2 = 7 << 16;
+                    r29 = r29 + -32;
+                    r2 = r2 + 12724;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = readPages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r2;
+                    r16 = r0 + 34;
+                    /* Next insn is delay slot */ 
+                    pc=0x2d850;
+                    continue;
+                case 0x2d82c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d834;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2d834:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d840;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2d840:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d848;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2d848:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d8e0;
+                        continue;
+                    }
+                case 0x2d850:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d82c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2d868;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2d868:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d8ac;
+                        continue;
+                    }
+                case 0x2d878:
+                    if(r4 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d8c8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2d888;
+                    pc=0x18c00;
+                    run_18c00(); return;
+                case 0x2d888:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2d894;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2d894:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d89c;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2d89c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d878;
+                        continue;
+                    }
+                case 0x2d8ac:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2d8c8:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d8d0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2d8d0:
+                    /* Next insn is delay slot */ 
+                    r31=0x2d8d8;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2d8d8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2d850;
+                        continue;
+                    }
+                case 0x2d8e0:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r17;
+                    r2 = r0 + 1;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2da00:
+                    pc=0x2da00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2da00() throws ExecutionException { /* 0x2da00 - 0x2dc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2da00:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r17 = readPages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff];
+                    r16 = r0 + 34;
+                    /* Next insn is delay slot */ 
+                    pc=0x2da44;
+                    continue;
+                case 0x2da20:
+                    /* Next insn is delay slot */ 
+                    r31=0x2da28;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2da28:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2da34;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2da34:
+                    /* Next insn is delay slot */ 
+                    r31=0x2da3c;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2da3c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dad4;
+                        continue;
+                    }
+                case 0x2da44:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2da20;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2da5c;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2da5c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2daa0;
+                        continue;
+                    }
+                case 0x2da6c:
+                    if(r4 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dabc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2da7c;
+                    pc=0x18c00;
+                    run_18c00(); return;
+                case 0x2da7c:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2da88;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2da88:
+                    /* Next insn is delay slot */ 
+                    r31=0x2da90;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2da90:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2da6c;
+                        continue;
+                    }
+                case 0x2daa0:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2dabc:
+                    /* Next insn is delay slot */ 
+                    r31=0x2dac4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2dac4:
+                    /* Next insn is delay slot */ 
+                    r31=0x2dacc;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2dacc:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2da44;
+                        continue;
+                    }
+                case 0x2dad4:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r17;
+                    r2 = r0 + 1;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2dc00:
+                    pc=0x2dc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2dc00() throws ExecutionException { /* 0x2dc00 - 0x2de00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2dc00:
+                    r2 = 7 << 16;
+                    r29 = r29 + -32;
+                    r2 = r2 + 12716;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = readPages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r2;
+                    r16 = r0 + 34;
+                    /* Next insn is delay slot */ 
+                    pc=0x2dc50;
+                    continue;
+                case 0x2dc2c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2dc34;
+                    pc=0x15e00;
+                    run_15e00(); return;
+                case 0x2dc34:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2dc40;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2dc40:
+                    /* Next insn is delay slot */ 
+                    r31=0x2dc48;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2dc48:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dce0;
+                        continue;
+                    }
+                case 0x2dc50:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dc2c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2dc68;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2dc68:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dcac;
+                        continue;
+                    }
+                case 0x2dc78:
+                    if(r4 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dcc8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2dc88;
+                    pc=0x18c00;
+                    run_18c00(); return;
+                case 0x2dc88:
+                    r4 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2dc94;
+                    pc=0x25e00;
+                    run_25e00(); return;
+                case 0x2dc94:
+                    /* Next insn is delay slot */ 
+                    r31=0x2dc9c;
+                    pc=0x1c600;
+                    run_1c600(); return;
+                case 0x2dc9c:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dc78;
+                        continue;
+                    }
+                case 0x2dcac:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2dcc8:
+                    /* Next insn is delay slot */ 
+                    r31=0x2dcd0;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2dcd0:
+                    /* Next insn is delay slot */ 
+                    r31=0x2dcd8;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2dcd8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dc50;
+                        continue;
+                    }
+                case 0x2dce0:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30592)>>>12][((r28+-30592)>>>2)&0x3ff] = r17;
+                    r2 = r0 + 1;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2de00:
+                    pc=0x2de00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2de00() throws ExecutionException { /* 0x2de00 - 0x2e000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2de00:
+                    r29 = r29 + -64;
+                    r4 = r29 + 16;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r19;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r18;
+                    r19 = 7 << 16;
+                    r18 = 7 << 16;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r17;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r16;
+                    r17 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2de30;
+                    pc=0x16000;
+                    run_16000(); return;
+                case 0x2de30:
+                    r18 = r18 + -1024;
+                    r19 = r19 + -1016;
+                case 0x2de38:
+                    /* Next insn is delay slot */ 
+                    r31=0x2de40;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2de40:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2de90;
+                        continue;
+                    }
+                case 0x2de48:
+                    /* Next insn is delay slot */ 
+                    r31=0x2de50;
+                    pc=0x1f400;
+                    run_1f400(); return;
+                case 0x2de50:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dea0;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r18 + r0;
+                    r16 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2de74;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x2de74:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dec0;
+                        continue;
+                    }
+                    r17 = r17 | 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x2de88;
+                    pc=0x20000;
+                    run_20000(); return;
+                case 0x2de88:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2de48;
+                        continue;
+                    }
+                case 0x2de90:
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2dea0;
+                    pc=0x27e00;
+                    run_27e00(); return;
+                case 0x2dea0:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r19 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r18 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r17 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r16 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2dec0:
+                    r4 = r16 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ded0;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x2ded0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2dee4;
+                        continue;
+                    }
+                    r17 = r17 | 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x2de38;
+                    continue;
+                case 0x2dee4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -1004;
+                    /* Next insn is delay slot */ 
+                    r31=0x2def4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2def4:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r19 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r18 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r17 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r16 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2e000:
+                    pc=0x2e000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2e000() throws ExecutionException { /* 0x2e000 - 0x2e200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2e000:
+                    r29 = r29 + -24;
+                    r4 = r0 + 80;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x2e014;
+                    pc=0x17600;
+                    run_17600(); return;
+                case 0x2e014:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = r28 + -30668;
+                    r5 = r5 + 8940;
+                    r29 = r29 + 24;
+                    writePages[(r28+-30672)>>>12][((r28+-30672)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x30e00;
+                    run_30e00(); return;
+                case 0x2e200:
+                    pc=0x2e200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2e200() throws ExecutionException { /* 0x2e200 - 0x2e400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2e200:
+                    r29 = r29 + -32;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2e214;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2e214:
+                    /* Next insn is delay slot */ 
+                    r31=0x2e21c;
+                    pc=0x1f400;
+                    run_1f400(); return;
+                case 0x2e21c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2e240;
+                        continue;
+                    }
+                case 0x2e224:
+                    /* Next insn is delay slot */ 
+                    r31=0x2e22c;
+                    pc=0x1c800;
+                    run_1c800(); return;
+                case 0x2e22c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2e240:
+                    r4 = readPages[(r28+-30668)>>>12][((r28+-30668)>>>2)&0x3ff];
+                    r6 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2e254;
+                    pc=0x31000;
+                    run_31000(); return;
+                case 0x2e254:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2e2b4;
+                        continue;
+                    }
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2e2b4;
+                        continue;
+                    }
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 32;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2e2cc;
+                        continue;
+                    }
+                case 0x2e27c:
+                    /* Next insn is delay slot */ 
+                    pc=r16;
+                    r31=0x2e284;
+                    return;
+                case 0x2e284:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2e224;
+                        continue;
+                    }
+                    r3 = r0 + 1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2e22c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2e2a0;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x2e2a0:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2e2b4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -972;
+                    /* Next insn is delay slot */ 
+                    r31=0x2e2c4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2e2c4:
+                    /* Next insn is delay slot */ 
+                    pc=0x2e224;
+                    continue;
+                case 0x2e2cc:
+                    /* Next insn is delay slot */ 
+                    r31=0x2e2d4;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2e2d4:
+                    /* Next insn is delay slot */ 
+                    pc=0x2e27c;
+                    continue;
+                case 0x2e400:
+                    pc=0x2e400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2e400() throws ExecutionException { /* 0x2e400 - 0x2e600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2e400:
+                    r2 = readPages[(r28+-30664)>>>12][((r28+-30664)>>>2)&0x3ff];
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    r2 = r2 + 1;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    writePages[(r28+-30664)>>>12][((r28+-30664)>>>2)&0x3ff] = r2;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = r6;
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = r7;
+                    writePages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2e600:
+                    pc=0x2e600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2e600() throws ExecutionException { /* 0x2e600 - 0x2e800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2e600:
+                    r2 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2e618;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2e618:
+                    r4 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x2e800:
+                    pc=0x2e800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2e800() throws ExecutionException { /* 0x2e800 - 0x2ea00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2e800:
+                    r3 = r0 + 1;
+                    r2 = 7 << 16;
+                    writePages[(r2+16928)>>>12][((r2+16928)>>>2)&0x3ff] = r3;
+                    writePages[(r28+-30664)>>>12][((r28+-30664)>>>2)&0x3ff] = r3;
+                    r3 = 7 << 16;
+                    r2 = r2 + 16928;
+                    r3 = r3 + 12764;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r3 = 7 << 16;
+                    r3 = r3 + 6068;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ea00:
+                    pc=0x2ea00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2ea00() throws ExecutionException { /* 0x2ea00 - 0x2ec00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2ea00:
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r6 = r0 + 16;
+                    r7 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r3 = r4 + r0;
+                    r7 = r7 & 272;
+                    if(r7 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ea24;
+                        continue;
+                    }
+                case 0x2ea1c:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ea24:
+                    r6 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    if(r6 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ea1c;
+                        continue;
+                    }
+                    r4 = r5 + r0;
+                    r6 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r7 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r5 = r5 + -652;
+                    /* Next insn is delay slot */ 
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x2ec00:
+                    pc=0x2ec00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2ec00() throws ExecutionException { /* 0x2ec00 - 0x2ee00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2ec00:
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r3 = r4 + r0;
+                    r6 = readPages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff];
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ec2c;
+                        continue;
+                    }
+                    r7 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r6 = r0 + 16;
+                    r7 = r7 & 272;
+                    if(r7 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ec34;
+                        continue;
+                    }
+                case 0x2ec2c:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ec34:
+                    r6 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    if(r6 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ec2c;
+                        continue;
+                    }
+                    r4 = r5 + r0;
+                    r6 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r7 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r5 = r5 + -652;
+                    /* Next insn is delay slot */ 
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x2ee00:
+                    pc=0x2ee00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2ee00() throws ExecutionException { /* 0x2ee00 - 0x2f000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2ee00:
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r3 = r4 + r0;
+                    r6 = readPages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff];
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ee2c;
+                        continue;
+                    }
+                    r7 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r6 = r0 + 16;
+                    r7 = r7 & 272;
+                    if(r7 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ee34;
+                        continue;
+                    }
+                case 0x2ee2c:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ee34:
+                    r6 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    if(r6 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ee2c;
+                        continue;
+                    }
+                    r4 = r5 + r0;
+                    r6 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r7 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r5 = r5 + -652;
+                    /* Next insn is delay slot */ 
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x2f000:
+                    pc=0x2f000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2f000() throws ExecutionException { /* 0x2f000 - 0x2f200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2f000:
+                    r2 = readPages[(r28+-30740)>>>12][((r28+-30740)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r18 = r4 + r0;
+                    r17 = r5 + r0;
+                    r16 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f03c;
+                        continue;
+                    }
+                    r3 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f200;
+                        run_2f200(); return;
+                    }
+                case 0x2f03c:
+                    r5 = 7 << 16;
+                    r6 = readPages[(r18+12)>>>12][((r18+12)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r5 = r5 + -628;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f054;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x2f054:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 4;
+                    r2 = r2 & 7;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f1dc;
+                        continue;
+                    }
+                    r3 = r0 + 6;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f1dc;
+                        continue;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f13c;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -608;
+                    r5 = r0 + 1;
+                    r6 = r0 + 3;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f09c;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x2f09c:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f16c;
+                        continue;
+                    }
+                case 0x2f0b0:
+                    r2 = r2 & 256;
+                    r4 = r17 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f1c0;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r7 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r6 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r5 = r5 + -604;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f0d8;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x2f0d8:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 & 32;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f19c;
+                        continue;
+                    }
+                case 0x2f0ec:
+                    r2 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f118;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -580;
+                    r5 = r0 + 1;
+                    r6 = r0 + 9;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f118;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x2f118:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r5 = r17 + r0;
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r0 + 10;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x3c000;
+                    run_3c000(); return;
+                case 0x2f13c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -624;
+                    r5 = r0 + 1;
+                    r6 = r0 + 5;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f158;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x2f158:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 & 16;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f0b0;
+                        continue;
+                    }
+                case 0x2f16c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -592;
+                    r5 = r0 + 1;
+                    r6 = r0 + 2;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f188;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x2f188:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 & 32;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f0ec;
+                        continue;
+                    }
+                case 0x2f19c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -588;
+                    r5 = r0 + 1;
+                    r6 = r0 + 4;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f1b8;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x2f1b8:
+                    /* Next insn is delay slot */ 
+                    pc=0x2f0ec;
+                    continue;
+                case 0x2f1c0:
+                    r5 = 7 << 16;
+                    r6 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r5 = r5 + -596;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f1d4;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x2f1d4:
+                    /* Next insn is delay slot */ 
+                    pc=0x2f0d8;
+                    continue;
+                case 0x2f1dc:
+                    r4 = 7 << 16;
+                    r4 = r4 + -616;
+                    r5 = r0 + 1;
+                    r6 = r0 + 5;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f1f8;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x2f1f8:
+                    /* Next insn is delay slot */ 
+                    pc=0x2f09c;
+                    continue;
+                case 0x2f200:
+                    pc=0x2f200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2f200() throws ExecutionException { /* 0x2f200 - 0x2f400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2f200:
+                    r4 = 7 << 16;
+                    r4 = r4 + -636;
+                    r5 = r0 + 1;
+                    r6 = r0 + 5;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f21c;
+                    pc=0x3dc00;
+                    run_3dc00(); return;
+                case 0x2f21c:
+                    /* Next insn is delay slot */ 
+                    pc=0x2f03c;
+                    run_2f000(); return;
+                case 0x2f400:
+                    pc=0x2f400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2f400() throws ExecutionException { /* 0x2f400 - 0x2f600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2f400:
+                    r29 = r29 + -40;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r16;
+                    r16 = r5 + r0;
+                    r5 = 7 << 16;
+                    r6 = r4 + r0;
+                    r5 = r5 + 16944;
+                    r4 = r29 + 16;
+                    r7 = r0 + 1;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f42c;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x2f42c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f488;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r16 = r16 & 7;
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f474;
+                        continue;
+                    }
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r3 = r3 & 7;
+                    if(r3 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f474;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -568;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f470;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2f470:
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                case 0x2f474:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2f488:
+                    r4 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f494;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x2f494:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r16;
+                    r16 = r16 & 256;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f4d4;
+                        continue;
+                    }
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                case 0x2f4ac:
+                    r3 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    writePages[(r2+28)>>>12][((r2+28)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff] = r0;
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r2;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2f4d4:
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2f4ac;
+                    continue;
+                case 0x2f600:
+                    pc=0x2f600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2f600() throws ExecutionException { /* 0x2f600 - 0x2f800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2f600:
+                    r29 = r29 + -40;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r2 = r16 & 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    r18 = r5 + r0;
+                    r19 = r6 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f63c;
+                        continue;
+                    }
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f6e8;
+                        continue;
+                    }
+                case 0x2f63c:
+                    r4 = r17 + r0;
+                    r5 = r18 + r0;
+                    r6 = r0 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f650;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2f650:
+                    r2 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                case 0x2f654:
+                    r4 = r16 & 40;
+                    r3 = r0 + 32;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f6a8;
+                        continue;
+                    }
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f6bc;
+                        continue;
+                    }
+                case 0x2f66c:
+                    r3 = r16 & 55;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f74c;
+                        continue;
+                    }
+                case 0x2f678:
+                    r3 = r0 + -8;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r2 & r3;
+                    r2 = r2 | r16;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2f6a8:
+                    r3 = r0 + -9;
+                    r2 = r2 & r3;
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r2;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f66c;
+                        continue;
+                    }
+                case 0x2f6bc:
+                    r16 = r16 & 32;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r2 | r16;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2f6e8:
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r3 = r2 ^ r16;
+                    r3 = r3 & 256;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f730;
+                        continue;
+                    }
+                    r3 = r16 & 256;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f75c;
+                        continue;
+                    }
+                    f2 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    f0 = readPages[(r5+12)>>>12][((r5+12)>>>2)&0x3ff];
+                    f3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    f1 = readPages[(r5+8)>>>12][((r5+8)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f654;
+                        continue;
+                    }
+                case 0x2f730:
+                    r4 = 7 << 16;
+                    r4 = r4 + -544;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f740;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2f740:
+                    r2 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x2f654;
+                    continue;
+                case 0x2f74c:
+                    r3 = r2 & 7;
+                    r16 = r3 | r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x2f678;
+                    continue;
+                case 0x2f75c:
+                    r4 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r3 = readPages[(r5+8)>>>12][((r5+8)>>>2)&0x3ff];
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f730;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x2f654;
+                    continue;
+                case 0x2f800:
+                    pc=0x2f800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2f800() throws ExecutionException { /* 0x2f800 - 0x2fa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2f800:
+                    r29 = r29 + -88;
+                    r2 = r4 + r0;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r18;
+                    r18 = r5 + r0;
+                    r5 = 7 << 16;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r19;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r17;
+                    r19 = r7 + r0;
+                    r17 = r6 + r0;
+                    r4 = r29 + 16;
+                    r5 = r5 + 16944;
+                    r6 = r2 + r0;
+                    r7 = r0 + 1;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r31;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f844;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x2f844:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f9cc;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r17 = r17 & 7;
+                    r16 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f884;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 & 7;
+                    if(r2 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f884;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -568;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f884;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2f884:
+                    r18 = r18 & 1;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f8a0;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-32332)>>>12][((r28+-32332)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f9b4;
+                        continue;
+                    }
+                case 0x2f8a0:
+                    r4 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f8ac;
+                    pc=0x28000;
+                    run_28000(); return;
+                case 0x2f8ac:
+                    r17 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r18 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r3 = r17 & 16;
+                    r18 = r18 & 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r4 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f938;
+                        continue;
+                    }
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f988;
+                        continue;
+                    }
+                    r3 = r17 & 256;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fa34;
+                        run_2fa00(); return;
+                    }
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fa24;
+                        run_2fa00(); return;
+                    }
+                    f2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    f0 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    f1 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fa34;
+                        run_2fa00(); return;
+                    }
+                case 0x2f910:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r18 = r18 | r17;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r18;
+                    r19 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r18 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r17 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r16 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2f938:
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r4;
+                    r5 = r29 + 16;
+                    r4 = r16 + r0;
+                    r6 = r0 + 24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f954;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2f954:
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f910;
+                        continue;
+                    }
+                    r17 = r17 & 32;
+                    r18 = r18 | r17;
+                case 0x2f964:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r18;
+                    r19 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r18 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r17 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r16 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2f988:
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r4;
+                    r5 = r29 + 16;
+                    r4 = r16 + r0;
+                    r6 = r0 + 24;
+                    r17 = r17 & 32;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f9a8;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2f9a8:
+                    r18 = r18 | r17;
+                    /* Next insn is delay slot */ 
+                    pc=0x2f964;
+                    continue;
+                case 0x2f9b4:
+                    r4 = 7 << 16;
+                    r4 = r4 + -520;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f9c4;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x2f9c4:
+                    /* Next insn is delay slot */ 
+                    pc=0x2f8a0;
+                    continue;
+                case 0x2f9cc:
+                    r4 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x2f9d8;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x2f9d8:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r17;
+                    r17 = r17 & 256;
+                    r16 = r2 + r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fa14;
+                        run_2fa00(); return;
+                    }
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                case 0x2f9f4:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    writePages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff] = r2;
+                case 0x2fa00:
+                    pc=0x2fa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2fa00() throws ExecutionException { /* 0x2fa00 - 0x2fc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2fa00:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x2f884;
+                    run_2f800(); return;
+                case 0x2fa14:
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2f9f4;
+                    run_2f800(); return;
+                case 0x2fa24:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2f910;
+                        run_2f800(); return;
+                    }
+                case 0x2fa34:
+                    r4 = 7 << 16;
+                    r4 = r4 + -544;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fa44;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2fa44:
+                    /* Next insn is delay slot */ 
+                    pc=0x2f910;
+                    run_2f800(); return;
+                case 0x2fc00:
+                    pc=0x2fc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2fc00() throws ExecutionException { /* 0x2fc00 - 0x2fe00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2fc00:
+                    r29 = r29 + -88;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r19;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r18;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r17;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r16;
+                    r19 = r5 + r0;
+                    r16 = r4 + r0;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fc28;
+                    pc=0x20200;
+                    run_20200(); return;
+                case 0x2fc28:
+                    addr=r28+-30588;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r18 = r2 + r0;
+                    r17 = r29 + 16;
+                    r5 = 7 << 16;
+                    r2 = r0 + 61;
+                    r4 = r17 + r0;
+                    r5 = r5 + 16944;
+                    r6 = r16 + r0;
+                    r7 = r0 + 1;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fd6c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x2fc5c;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x2fc5c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fe80;
+                        run_2fe00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r18 = r18 & 7;
+                    r16 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fc9c;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 & 7;
+                    if(r2 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fc9c;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -568;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fc9c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2fc9c:
+                    r19 = r19 & 1;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fcb8;
+                        continue;
+                    }
+                case 0x2fca8:
+                    r2 = readPages[(r28+-32332)>>>12][((r28+-32332)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fed0;
+                        run_2fe00(); return;
+                    }
+                case 0x2fcb8:
+                    r4 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fcc4;
+                    pc=0x28000;
+                    run_28000(); return;
+                case 0x2fcc4:
+                    r18 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r3 = r18 & 16;
+                    r19 = r19 & 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r4 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fd48;
+                        continue;
+                    }
+                case 0x2fce8:
+                    r3 = r18 & 256;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fe68;
+                        run_2fe00(); return;
+                    }
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fe58;
+                        run_2fe00(); return;
+                    }
+                    f2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    f0 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    f1 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fe68;
+                        run_2fe00(); return;
+                    }
+                case 0x2fd20:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r18 = r19 | r18;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r18;
+                    r19 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r18 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r17 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r16 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2fd48:
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r4;
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    r6 = r0 + 24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r19;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fd64;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2fd64:
+                    /* Next insn is delay slot */ 
+                    pc=0x2fd20;
+                    continue;
+                case 0x2fd6c:
+                    /* Next insn is delay slot */ 
+                    r31=0x2fd74;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x2fd74:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ff28;
+                        run_2fe00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r18 = r18 & 7;
+                    r16 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fdb4;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 & 7;
+                    if(r2 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fdb4;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -568;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fdb4;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2fdb4:
+                    /* Next insn is delay slot */ 
+                    r31=0x2fdbc;
+                    pc=0x1c000;
+                    run_1c000(); return;
+                case 0x2fdbc:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fdc8;
+                    pc=0x16400;
+                    run_16400(); return;
+                case 0x2fdc8:
+                    /* Next insn is delay slot */ 
+                    r31=0x2fdd0;
+                    pc=0x31a00;
+                    run_31a00(); return;
+                case 0x2fdd0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fde0;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                case 0x2fde0:
+                    r18 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r18 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ff70;
+                        run_2fe00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = r2 ^ r18;
+                case 0x2fe00:
+                    pc=0x2fe00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_2fe00() throws ExecutionException { /* 0x2fe00 - 0x30000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x2fe00:
+                    r3 = r3 & 256;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fe3c;
+                        continue;
+                    }
+                    r3 = r18 & 256;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fff8;
+                        continue;
+                    }
+                    f2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    f0 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    f1 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ff88;
+                        continue;
+                    }
+                case 0x2fe3c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -544;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fe4c;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2fe4c:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x2ff88;
+                    continue;
+                case 0x2fe58:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fd20;
+                        run_2fc00(); return;
+                    }
+                case 0x2fe68:
+                    r4 = 7 << 16;
+                    r4 = r4 + -544;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fe78;
+                    pc=0x1b000;
+                    run_1b000(); return;
+                case 0x2fe78:
+                    /* Next insn is delay slot */ 
+                    pc=0x2fd20;
+                    run_2fc00(); return;
+                case 0x2fe80:
+                    r4 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fe8c;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x2fe8c:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r18;
+                    r18 = r18 & 256;
+                    r16 = r2 + r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ff18;
+                        continue;
+                    }
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                case 0x2fea8:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r19 = r19 & 1;
+                    writePages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r16;
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fca8;
+                        run_2fc00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x2fcb8;
+                    run_2fc00(); return;
+                case 0x2fed0:
+                    r4 = 7 << 16;
+                    r4 = r4 + -520;
+                    /* Next insn is delay slot */ 
+                    r31=0x2fee0;
+                    pc=0x1ae00;
+                    run_1ae00(); return;
+                case 0x2fee0:
+                    r4 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    r31=0x2feec;
+                    pc=0x28000;
+                    run_28000(); return;
+                case 0x2feec:
+                    r18 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r3 = r18 & 16;
+                    r19 = r19 & 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r4 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fd48;
+                        run_2fc00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x2fce8;
+                    run_2fc00(); return;
+                case 0x2ff18:
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2fea8;
+                    continue;
+                case 0x2ff28:
+                    r4 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ff34;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x2ff34:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r18;
+                    r18 = r18 & 256;
+                    r16 = r2 + r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30014;
+                        run_30000(); return;
+                    }
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                case 0x2ff50:
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    writePages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x2fdb4;
+                    run_2fc00(); return;
+                case 0x2ff70:
+                    r4 = r16 + r0;
+                    r5 = r17 + r0;
+                    r6 = r0 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ff84;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x2ff84:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x2ff88:
+                    r4 = r18 & 40;
+                    r3 = r0 + 32;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ffe4;
+                        continue;
+                    }
+                case 0x2ff98:
+                    r3 = r18 & 55;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2ffac;
+                        continue;
+                    }
+                    r3 = r2 & 7;
+                    r18 = r3 | r18;
+                case 0x2ffac:
+                    r3 = r0 + -8;
+                    r2 = r2 & r3;
+                    r18 = r2 | r18;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    r31=0x2ffc4;
+                    pc=0x1ce00;
+                    run_1ce00(); return;
+                case 0x2ffc4:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r19 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r18 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r17 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r16 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x2ffe4:
+                    r3 = r0 + -9;
+                    r2 = r2 & r3;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x2ff98;
+                    continue;
+                case 0x2fff8:
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                case 0x30000:
+                    pc=0x30000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_30000() throws ExecutionException { /* 0x30000 - 0x30200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x30000:
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x2fe3c;
+                        run_2fe00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x2ff88;
+                    run_2fe00(); return;
+                case 0x30014:
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x2ff50;
+                    run_2fe00(); return;
+                case 0x30200:
+                    pc=0x30200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_30200() throws ExecutionException { /* 0x30200 - 0x30400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x30200:
+                    r29 = r29 + -32;
+                    r5 = 7 << 16;
+                    r5 = r5 + 16944;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r6 = r0 + r0;
+                    r16 = r4 + r0;
+                    r7 = r0 + 1;
+                    r4 = r29 + 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x3022c;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x3022c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30268;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r16;
+                    r3 = r3 & 32;
+                    r3 = r3 | 80;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x30268:
+                    r4 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x30274;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x30274:
+                    r3 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    writePages[(r2+28)>>>12][((r2+28)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    writePages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff] = r0;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = r2;
+                    r3 = r0 + 80;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r16;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x30400:
+                    pc=0x30400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_30400() throws ExecutionException { /* 0x30400 - 0x30600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x30400:
+                    r7 = r4 + r0;
+                    r6 = 3 << 16;
+                    r4 = 7 << 16;
+                    r4 = r4 + 16944;
+                    r5 = r0 + r0;
+                    r6 = r6 + -4096;
+                    /* Next insn is delay slot */ 
+                    pc=0x31800;
+                    run_31800(); return;
+                case 0x30600:
+                    pc=0x30600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_30600() throws ExecutionException { /* 0x30600 - 0x30800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x30600:
+                    r29 = r29 + -32;
+                    r6 = 3 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = 7 << 16;
+                    r16 = r4 + r0;
+                    r7 = r16 + r0;
+                    r4 = r17 + 16944;
+                    r6 = r6 + -4608;
+                    r5 = r0 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x30634;
+                    pc=0x31800;
+                    run_31800(); return;
+                case 0x30634:
+                    r5 = r16 + r0;
+                    r4 = r0 + 10;
+                    /* Next insn is delay slot */ 
+                    r31=0x30644;
+                    pc=0x3c000;
+                    run_3c000(); return;
+                case 0x30644:
+                    r6 = 3 << 16;
+                    r7 = r16 + r0;
+                    r4 = r17 + 16944;
+                    r6 = r6 + -5120;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x30660;
+                    pc=0x31800;
+                    run_31800(); return;
+                case 0x30660:
+                    r5 = r16 + r0;
+                    r4 = r0 + 10;
+                    /* Next insn is delay slot */ 
+                    r31=0x30670;
+                    pc=0x3c000;
+                    run_3c000(); return;
+                case 0x30670:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = r17 + 16944;
+                    r6 = 3 << 16;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r7 = r16 + r0;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    r6 = r6 + -5632;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x31800;
+                    run_31800(); return;
+                case 0x30800:
+                    pc=0x30800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_30800() throws ExecutionException { /* 0x30800 - 0x30a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x30800:
+                    r29 = r29 + -40;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x30828;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x30828:
+                    r2 = readPages[(r28+-32228)>>>12][((r28+-32228)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r29 + 16;
+                    r5 = r5 + 16944;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x30848;
+                    pc=0x31200;
+                    run_31200(); return;
+                case 0x30848:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3095c;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r18 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    r3 = readPages[(r18+28)>>>12][((r18+28)>>>2)&0x3ff];
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30994;
+                        continue;
+                    }
+                    writePages[(r18+28)>>>12][((r18+28)>>>2)&0x3ff] = r2;
+                    writePages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff] = r0;
+                    r16 = r0 + r0;
+                case 0x3087c:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x308cc;
+                    continue;
+                case 0x3089c:
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = r3 + 1;
+                    r3 = r5 + r3;
+                    r5 = r16 & 15;
+                    r5 = r5 + 97;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r6;
+                    r16 = r16 >>> 4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3091c;
+                        continue;
+                    }
+                case 0x308c8:
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                case 0x308cc:
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    if(r5 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3089c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x308e4;
+                    pc=0x17800;
+                    run_17800(); return;
+                case 0x308e4:
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r3 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    r5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = r3 + 1;
+                    r3 = r5 + r3;
+                    r5 = r16 & 15;
+                    r5 = r5 + 97;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r6;
+                    r16 = r16 >>> 4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x308c8;
+                        continue;
+                    }
+                case 0x3091c:
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x30928;
+                    pc=0x17c00;
+                    run_17c00(); return;
+                case 0x30928:
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30940;
+                        continue;
+                    }
+                    r2 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff] = r2;
+                case 0x30940:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3095c:
+                    r4 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x30968;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x30968:
+                    r18 = r2 + r0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    writePages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff] = r0;
+                    r2 = readPages[(r28+-30584)>>>12][((r28+-30584)>>>2)&0x3ff];
+                    writePages[(r18+28)>>>12][((r18+28)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r18;
+                case 0x30994:
+                    r16 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3087c;
+                    continue;
+                case 0x30a00:
+                    pc=0x30a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_30a00() throws ExecutionException { /* 0x30a00 - 0x30c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x30a00:
+                    r2 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r5 = r2 + 1;
+                    r2 = r0 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30a40;
+                        continue;
+                    }
+                case 0x30a1c:
+                    r6 = r2 >>> 25;
+                    r2 = r2 << 7;
+                    r2 = r2 | r6;
+                    r5 = r5 + 1;
+                    r2 = r3 ^ r2;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30a1c;
+                        continue;
+                    }
+                case 0x30a40:
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x30c00:
+                    pc=0x30c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_30c00() throws ExecutionException { /* 0x30c00 - 0x30e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x30c00:
+                    r2 = readPages[(r5+12)>>>12][((r5+12)>>>2)&0x3ff];
+                    r3 = r0 + r0;
+                    r6 = r2 + 1;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30c40;
+                        continue;
+                    }
+                case 0x30c1c:
+                    r7 = r3 >>> 25;
+                    r3 = r3 << 7;
+                    r3 = r3 | r7;
+                    r6 = r6 + 1;
+                    r3 = r2 ^ r3;
+                    addr=r6+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30c1c;
+                        continue;
+                    }
+                case 0x30c40:
+                    writePages[(r5+8)>>>12][((r5+8)>>>2)&0x3ff] = r3;
+                case 0x30c44:
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30c7c;
+                        continue;
+                    }
+                case 0x30c54:
+                    r4 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r4 = ((r4 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30c88;
+                        continue;
+                    }
+                    r4 = r2 + r0;
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30c54;
+                        continue;
+                    }
+                case 0x30c7c:
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x30c88:
+                    r4 = r2 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x30c44;
+                    continue;
+                case 0x30e00:
+                    pc=0x30e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_30e00() throws ExecutionException { /* 0x30e00 - 0x31000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x30e00:
+                    r2 = readPages[(r5+8)>>>12][((r5+8)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30ec0;
+                        continue;
+                    }
+                case 0x30e10:
+                    r8 = r5 + 20;
+                    r2 = readPages[(r8+-8)>>>12][((r8+-8)>>>2)&0x3ff];
+                    r3 = r0 + r0;
+                    r6 = r2 + 1;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30e54;
+                        continue;
+                    }
+                case 0x30e30:
+                    r7 = r3 >>> 25;
+                    r3 = r3 << 7;
+                    r3 = r3 | r7;
+                    r6 = r6 + 1;
+                    r3 = r2 ^ r3;
+                    addr=r6+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30e30;
+                        continue;
+                    }
+                case 0x30e54:
+                    writePages[(r8+-12)>>>12][((r8+-12)>>>2)&0x3ff] = r3;
+                    r6 = r4 + r0;
+                case 0x30e5c:
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30e94;
+                        continue;
+                    }
+                case 0x30e6c:
+                    r6 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r6 = ((r6 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30eb4;
+                        continue;
+                    }
+                    r6 = r2 + r0;
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30e6c;
+                        continue;
+                    }
+                case 0x30e94:
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r5;
+                    r2 = readPages[(r8+8)>>>12][((r8+8)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30ec4;
+                        continue;
+                    }
+                    r5 = r8 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x30e10;
+                    continue;
+                case 0x30eb4:
+                    r6 = r2 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x30e5c;
+                    continue;
+                case 0x30ec0:
+                    r8 = r5 + r0;
+                case 0x30ec4:
+                    r2 = readPages[(r8+12)>>>12][((r8+12)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r5 = r2 + 1;
+                    r2 = r0 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30f04;
+                        continue;
+                    }
+                case 0x30ee0:
+                    r6 = r2 >>> 25;
+                    r2 = r2 << 7;
+                    r2 = r2 | r6;
+                    r5 = r5 + 1;
+                    r2 = r3 ^ r2;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30ee0;
+                        continue;
+                    }
+                case 0x30f04:
+                    writePages[(r8+8)>>>12][((r8+8)>>>2)&0x3ff] = r2;
+                case 0x30f08:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30f40;
+                        continue;
+                    }
+                case 0x30f18:
+                    r4 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r4 = ((r4 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30f4c;
+                        continue;
+                    }
+                    r4 = r3 + r0;
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x30f18;
+                        continue;
+                    }
+                case 0x30f40:
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x30f4c:
+                    r4 = r3 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x30f08;
+                    continue;
+                case 0x31000:
+                    pc=0x31000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_31000() throws ExecutionException { /* 0x31000 - 0x31200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x31000:
+                    r9 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r8 = r0 + r0;
+                    addr=r9+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r9 + 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3103c;
+                        continue;
+                    }
+                case 0x31018:
+                    r6 = r8 >>> 25;
+                    r8 = r8 << 7;
+                    r8 = r8 | r6;
+                    r3 = r3 + 1;
+                    r8 = r2 ^ r8;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31018;
+                        continue;
+                    }
+                case 0x3103c:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31068;
+                        continue;
+                    }
+                case 0x31044:
+                    r2 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r3 = ((r2 & 0xffffffffL) < (r8 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31074;
+                        continue;
+                    }
+                    r4 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31044;
+                        continue;
+                    }
+                case 0x31068:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x31074:
+                    if(r2 == r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31088;
+                        continue;
+                    }
+                case 0x3107c:
+                    r4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3103c;
+                    continue;
+                case 0x31088:
+                    r3 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r2 = r9 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x310a0;
+                    continue;
+                case 0x31098:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x310c4;
+                        continue;
+                    }
+                case 0x310a0:
+                    r2 = r2 + 1;
+                    r3 = r3 + 1;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r7 = tmp;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r6 = tmp;
+                    if(r6 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31098;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3107c;
+                    continue;
+                case 0x310c4:
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    writePages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x31200:
+                    pc=0x31200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_31200() throws ExecutionException { /* 0x31200 - 0x31400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x31200:
+                    r2 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    r29 = r29 + -48;
+                    r10 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    addr=r10+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r19 = r4 + r0;
+                    r8 = r10 + 1;
+                    r2 = r0 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3125c;
+                        continue;
+                    }
+                case 0x31238:
+                    r9 = r2 >>> 25;
+                    r2 = r2 << 7;
+                    r2 = r2 | r9;
+                    r8 = r8 + 1;
+                    r2 = r3 ^ r2;
+                    addr=r8+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31238;
+                        continue;
+                    }
+                case 0x3125c:
+                    r17 = r2 ^ r6;
+                    r2 = r17 >>> 16;
+                    r2 = r2 ^ r17;
+                    r16 = r2 >>> 8;
+                    r16 = r16 ^ r2;
+                    r16 = r16 & 255;
+                    r16 = r16 << 2;
+                    r16 = r5 + r16;
+                case 0x3127c:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x312b4;
+                        continue;
+                    }
+                case 0x3128c:
+                    r3 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r5 = ((r3 & 0xffffffffL) < (r17 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x312e0;
+                        continue;
+                    }
+                    r16 = r2 + r0;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3128c;
+                        continue;
+                    }
+                case 0x312b4:
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31368;
+                        continue;
+                    }
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r0;
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x312e0:
+                    if(r17 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x312f4;
+                        continue;
+                    }
+                case 0x312e8:
+                    r16 = r2 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x3127c;
+                    continue;
+                case 0x312f4:
+                    r3 = readPages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff];
+                    if(r6 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x312e8;
+                        continue;
+                    }
+                    r5 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r3 = r10 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3131c;
+                    continue;
+                case 0x31314:
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31340;
+                        continue;
+                    }
+                case 0x3131c:
+                    r3 = r3 + 1;
+                    r5 = r5 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r9 = tmp;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r8 = tmp;
+                    if(r8 == r9) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31314;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x312e8;
+                    continue;
+                case 0x31340:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r2;
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x31368:
+                    r4 = r0 + 24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x31378;
+                    pc=0x1b400;
+                    run_1b400(); return;
+                case 0x31378:
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-30596)>>>12][((r28+-30596)>>>2)&0x3ff];
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r17;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    writePages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff] = r6;
+                    r18 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3139c;
+                    pc=0x17a00;
+                    run_17a00(); return;
+                case 0x3139c:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    writePages[(r18+12)>>>12][((r18+12)>>>2)&0x3ff] = r2;
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r18;
+                    r2 = r0 + 1;
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r18;
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x31400:
+                    pc=0x31400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_31400() throws ExecutionException { /* 0x31400 - 0x31600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x31400:
+                    r29 = r29 + -64;
+                    r3 = r4 + r0;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r30;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r23;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r22;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r21;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r4;
+                    r30 = r5 + r0;
+                    r17 = r6 + r0;
+                    r16 = r7 + r0;
+                case 0x31440:
+                    r2 = readPages[(r3+20)>>>12][((r3+20)>>>2)&0x3ff];
+                    if(r2 != r30) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31460;
+                        continue;
+                    }
+                    r4 = r3 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x31460;
+                    return;
+                case 0x31460:
+                    r2 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3169c;
+                        run_31600(); return;
+                    }
+                case 0x3147c:
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = readPages[(r3+20)>>>12][((r3+20)>>>2)&0x3ff];
+                    if(r2 != r30) {
+                        /* Next insn is delay slot */ 
+                        pc=0x314a4;
+                        continue;
+                    }
+                    r4 = r3 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x314a4;
+                    return;
+                case 0x314a4:
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31680;
+                        run_31600(); return;
+                    }
+                case 0x314c0:
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = readPages[(r3+20)>>>12][((r3+20)>>>2)&0x3ff];
+                    if(r2 != r30) {
+                        /* Next insn is delay slot */ 
+                        pc=0x314e8;
+                        continue;
+                    }
+                    r4 = r3 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x314e8;
+                    return;
+                case 0x314e8:
+                    r2 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r22 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31664;
+                        run_31600(); return;
+                    }
+                case 0x31500:
+                    r2 = readPages[(r22+20)>>>12][((r22+20)>>>2)&0x3ff];
+                    if(r2 != r30) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31520;
+                        continue;
+                    }
+                    r4 = r22 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x31520;
+                    return;
+                case 0x31520:
+                    r23 = readPages[(r22+0)>>>12][((r22+0)>>>2)&0x3ff];
+                    if(r23 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31654;
+                        run_31600(); return;
+                    }
+                case 0x31530:
+                    r2 = readPages[(r23+20)>>>12][((r23+20)>>>2)&0x3ff];
+                    if(r2 == r30) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31734;
+                        run_31600(); return;
+                    }
+                case 0x31540:
+                    r20 = readPages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff];
+                    if(r20 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31644;
+                        run_31600(); return;
+                    }
+                case 0x31550:
+                    r2 = readPages[(r20+20)>>>12][((r20+20)>>>2)&0x3ff];
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3171c;
+                        run_31600(); return;
+                    }
+                case 0x31560:
+                    r19 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31634;
+                        run_31600(); return;
+                    }
+                case 0x31570:
+                    r2 = readPages[(r19+20)>>>12][((r19+20)>>>2)&0x3ff];
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31704;
+                        run_31600(); return;
+                    }
+                case 0x31580:
+                    r18 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31624;
+                        run_31600(); return;
+                    }
+                case 0x31590:
+                    r2 = readPages[(r18+20)>>>12][((r18+20)>>>2)&0x3ff];
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x316ec;
+                        run_31600(); return;
+                    }
+                case 0x315a0:
+                    r21 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    if(r21 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x315ec;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x31614;
+                    run_31600(); return;
+                case 0x315b8:
+                    r4 = readPages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x315dc;
+                        continue;
+                    }
+                    r5 = r30 + r0;
+                    r6 = r17 + r0;
+                    r7 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x315dc;
+                    pc=0x31400;
+                    continue;
+                case 0x315dc:
+                    r21 = readPages[(r21+4)>>>12][((r21+4)>>>2)&0x3ff];
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31614;
+                        run_31600(); return;
+                    }
+                case 0x315ec:
+                    r3 = readPages[(r21+20)>>>12][((r21+20)>>>2)&0x3ff];
+                    if(r30 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x315b8;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                case 0x31600:
+                    pc=0x31600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_31600() throws ExecutionException { /* 0x31600 - 0x31800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x31600:
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x3160c;
+                    return;
+                case 0x3160c:
+                    /* Next insn is delay slot */ 
+                    pc=0x315b8;
+                    run_31400(); return;
+                case 0x31614:
+                    r18 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31590;
+                        run_31400(); return;
+                    }
+                case 0x31624:
+                    r19 = readPages[(r19+4)>>>12][((r19+4)>>>2)&0x3ff];
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31570;
+                        run_31400(); return;
+                    }
+                case 0x31634:
+                    r20 = readPages[(r20+4)>>>12][((r20+4)>>>2)&0x3ff];
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31550;
+                        run_31400(); return;
+                    }
+                case 0x31644:
+                    r23 = readPages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff];
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31530;
+                        run_31400(); return;
+                    }
+                case 0x31654:
+                    r22 = readPages[(r22+4)>>>12][((r22+4)>>>2)&0x3ff];
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31500;
+                        run_31400(); return;
+                    }
+                case 0x31664:
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x314c0;
+                        run_31400(); return;
+                    }
+                case 0x31680:
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3147c;
+                        run_31400(); return;
+                    }
+                case 0x3169c:
+                    r3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r3 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31440;
+                        run_31400(); return;
+                    }
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x316ec:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x316fc;
+                    return;
+                case 0x316fc:
+                    /* Next insn is delay slot */ 
+                    pc=0x315a0;
+                    run_31400(); return;
+                case 0x31704:
+                    r4 = r19 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x31714;
+                    return;
+                case 0x31714:
+                    /* Next insn is delay slot */ 
+                    pc=0x31580;
+                    run_31400(); return;
+                case 0x3171c:
+                    r4 = r20 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x3172c;
+                    return;
+                case 0x3172c:
+                    /* Next insn is delay slot */ 
+                    pc=0x31560;
+                    run_31400(); return;
+                case 0x31734:
+                    r4 = r23 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r17;
+                    r31=0x31744;
+                    return;
+                case 0x31744:
+                    /* Next insn is delay slot */ 
+                    pc=0x31540;
+                    run_31400(); return;
+                case 0x31800:
+                    pc=0x31800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_31800() throws ExecutionException { /* 0x31800 - 0x31a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x31800:
+                    r29 = r29 + -48;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r21;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r20 = r4 + r0;
+                    r17 = r5 + r0;
+                    r19 = r6 + r0;
+                    r18 = r7 + r0;
+                    r21 = r4 + 1024;
+                case 0x31834:
+                    r16 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31880;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x318a8;
+                    continue;
+                case 0x3184c:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31870;
+                        continue;
+                    }
+                    r5 = r17 + r0;
+                    r6 = r19 + r0;
+                    r7 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x31870;
+                    pc=0x31400;
+                    run_31400(); return;
+                case 0x31870:
+                    r16 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x318a8;
+                        continue;
+                    }
+                case 0x31880:
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    if(r2 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3184c;
+                        continue;
+                    }
+                    r4 = r16 + r0;
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r19;
+                    r31=0x318a0;
+                    return;
+                case 0x318a0:
+                    /* Next insn is delay slot */ 
+                    pc=0x3184c;
+                    continue;
+                case 0x318a8:
+                    r20 = r20 + 4;
+                    if(r20 != r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x31834;
+                        continue;
+                    }
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r21 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x31a00:
+                    pc=0x31a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_31a00() throws ExecutionException { /* 0x31a00 - 0x31c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x31a00:
+                    r2 = readPages[(r28+-30656)>>>12][((r28+-30656)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-30660)>>>12][((r28+-30660)>>>2)&0x3ff];
+                    r2 = r3 | r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x31c00:
+                    pc=0x31c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_31c00() throws ExecutionException { /* 0x31c00 - 0x31e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x31c00:
+                    r29 = r29 + -24;
+                    r2 = r0 + 1;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r28+-30656)>>>12][((r28+-30656)>>>2)&0x3ff];
+                    writePages[(r28+-30656)>>>12][((r28+-30656)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x31c20;
+                    pc=0x1b600;
+                    run_1b600(); return;
+                case 0x31c20:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30656)>>>12][((r28+-30656)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x31e00:
+                    pc=0x31e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_31e00() throws ExecutionException { /* 0x31e00 - 0x32000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x31e00:
+                    writePages[(r28+-30660)>>>12][((r28+-30660)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32000:
+                    pc=0x32000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_32000() throws ExecutionException { /* 0x32000 - 0x32200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x32000:
+                    r2 = readPages[(r28+-30740)>>>12][((r28+-30740)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32034;
+                        continue;
+                    }
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32034;
+                        continue;
+                    }
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3203c;
+                        continue;
+                    }
+                case 0x32034:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3203c:
+                    r4 = 7 << 16;
+                    r4 = r4 + -484;
+                    /* Next insn is delay slot */ 
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x32200:
+                    pc=0x32200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_32200() throws ExecutionException { /* 0x32200 - 0x32400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x32200:
+                    r2 = readPages[(r28+-30740)>>>12][((r28+-30740)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32244;
+                        continue;
+                    }
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r2 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32244;
+                        continue;
+                    }
+                    r3 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32244;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r4 = r4 + -452;
+                    /* Next insn is delay slot */ 
+                    pc=0x1ac00;
+                    run_1ac00(); return;
+                case 0x32244:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32400:
+                    pc=0x32400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_32400() throws ExecutionException { /* 0x32400 - 0x32600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x32400:
+                    r29 = r29 + -32;
+                    r2 = f13;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = 32767 << 16;
+                    r16 = r16 | 65535;
+                    r16 = r16 & r2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r17 = r2 + r0;
+                    r2 = 17424 << 16;
+                    r2 = r16 < r2 ? 1 : 0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    f0 = f12;
+                    f1 = f13;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32480;
+                        continue;
+                    }
+                    r2 = 32752 << 16;
+                    r3 = r2 + 1;
+                    r3 = r16 < r3 ? 1 : 0;
+                    r5 = f12;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32608;
+                        run_32600(); return;
+                    }
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32600;
+                        run_32600(); return;
+                    }
+                case 0x32458:
+                    if(r17 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x326bc;
+                        run_32600(); return;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f0 = readPages[(r28+-32220)>>>12][((r28+-32220)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32224)>>>12][((r28+-32224)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32480:
+                    r2 = 16348 << 16;
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32660;
+                        run_32600(); return;
+                    }
+                    r2 = 15904 << 16;
+                    r16 = r16 < r2 ? 1 : 0;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32624;
+                        run_32600(); return;
+                    }
+                case 0x324a0:
+                    r2 = r0 + -1;
+                case 0x324a4:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-32164)>>>12][((r28+-32164)>>>2)&0x3ff];
+                    f8 = readPages[(r28+-32156)>>>12][((r28+-32156)>>>2)&0x3ff];
+                    f7 = readPages[(r28+-32168)>>>12][((r28+-32168)>>>2)&0x3ff];
+                    f9 = readPages[(r28+-32160)>>>12][((r28+-32160)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = r0 + -1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-32148)>>>12][((r28+-32148)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-32152)>>>12][((r28+-32152)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-32140)>>>12][((r28+-32140)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-32144)>>>12][((r28+-32144)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-32132)>>>12][((r28+-32132)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-32136)>>>12][((r28+-32136)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-32124)>>>12][((r28+-32124)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-32128)>>>12][((r28+-32128)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-32108)>>>12][((r28+-32108)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-32116)>>>12][((r28+-32116)>>>2)&0x3ff];
+                    f9 = readPages[(r28+-32112)>>>12][((r28+-32112)>>>2)&0x3ff];
+                    f7 = readPages[(r28+-32120)>>>12][((r28+-32120)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-32100)>>>12][((r28+-32100)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-32104)>>>12][((r28+-32104)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-32092)>>>12][((r28+-32092)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-32096)>>>12][((r28+-32096)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-32084)>>>12][((r28+-32084)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-32088)>>>12][((r28+-32088)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x326e8;
+                        run_32600(); return;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r5 = 7 << 16;
+                    r6 = 7 << 16;
+                    r4 = r2 << 3;
+                    r5 = r5 + -384;
+                    r6 = r6 + -416;
+                    r5 = r4 + r5;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r4 = r4 + r6;
+                    f6 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    f7 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    f3 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r3 = f4;
+                    r2 = f5;
+                    if(r17 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x326d0;
+                        run_32600(); return;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f0 = r3;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f1 = r2;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32600:
+                    pc=0x32600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_32600() throws ExecutionException { /* 0x32600 - 0x32800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x32600:
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32458;
+                        run_32400(); return;
+                    }
+                case 0x32608:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x3260c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32624:
+                    f4 = readPages[(r28+-32204)>>>12][((r28+-32204)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-32196)>>>12][((r28+-32196)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-32208)>>>12][((r28+-32208)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-32200)>>>12][((r28+-32200)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x324a0;
+                        run_32400(); return;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32660:
+                    /* Next insn is delay slot */ 
+                    r31=0x32668;
+                    pc=0x32a00;
+                    run_32a00(); return;
+                case 0x32668:
+                    r2 = 16371 << 16;
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x326fc;
+                        continue;
+                    }
+                    r2 = 16358 << 16;
+                    r16 = r16 < r2 ? 1 : 0;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32758;
+                        continue;
+                    }
+                    f2 = readPages[(r28+-32196)>>>12][((r28+-32196)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f3 = readPages[(r28+-32200)>>>12][((r28+-32200)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-32188)>>>12][((r28+-32188)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-32192)>>>12][((r28+-32192)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x324a4;
+                    run_32400(); return;
+                case 0x326bc:
+                    f0 = readPages[(r28+-32212)>>>12][((r28+-32212)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32216)>>>12][((r28+-32216)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3260c;
+                    continue;
+                case 0x326d0:
+                    r6 = 32768 << 16;
+                    f0 = r3;
+                    r4 = r2 ^ r6;
+                    f1 = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x3260c;
+                    continue;
+                case 0x326e8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x3260c;
+                    continue;
+                case 0x326fc:
+                    r2 = 16387 << 16;
+                    r2 = r2 | 32768;
+                    r16 = r16 < r2 ? 1 : 0;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3273c;
+                        continue;
+                    }
+                    f2 = readPages[(r28+-32180)>>>12][((r28+-32180)>>>2)&0x3ff];
+                    f6 = readPages[(r28+-32196)>>>12][((r28+-32196)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-32184)>>>12][((r28+-32184)>>>2)&0x3ff];
+                    f7 = readPages[(r28+-32200)>>>12][((r28+-32200)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r2 = r0 + 2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x324a4;
+                    run_32400(); return;
+                case 0x3273c:
+                    f2 = readPages[(r28+-32172)>>>12][((r28+-32172)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    f3 = readPages[(r28+-32176)>>>12][((r28+-32176)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x324a4;
+                    run_32400(); return;
+                case 0x32758:
+                    f2 = readPages[(r28+-32196)>>>12][((r28+-32196)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    f3 = readPages[(r28+-32200)>>>12][((r28+-32200)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x324a4;
+                    run_32400(); return;
+                case 0x32800:
+                    pc=0x32800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_32800() throws ExecutionException { /* 0x32800 - 0x32a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x32800:
+                    r2 = f13;
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r2 = r3 & r2;
+                    r3 = 16361 << 16;
+                    r3 = r3 + 8700;
+                    r29 = r29 + -48;
+                    r3 = r2 < r3 ? 1 : 0;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x328bc;
+                        continue;
+                    }
+                    r3 = 32752 << 16;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32860;
+                        continue;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = f2;
+                    r2 = f3;
+                case 0x32848:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f0 = r3;
+                    r29 = r29 + 48;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32860:
+                    r6 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x3286c;
+                    pc=0x35200;
+                    run_35200(); return;
+                case 0x3286c:
+                    r2 = r2 & 3;
+                    r3 = r0 + 1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32934;
+                        continue;
+                    }
+                    r4 = r0 + 2;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x328f0;
+                        continue;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32958;
+                        continue;
+                    }
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x328ac;
+                    pc=0x36e00;
+                    run_36e00(); return;
+                case 0x328ac:
+                    r3 = f0;
+                    r2 = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x32848;
+                    continue;
+                case 0x328bc:
+                    f14 = r0;
+                    f15 = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x328d0;
+                    pc=0x35c00;
+                    run_35c00(); return;
+                case 0x328d0:
+                    r3 = f0;
+                    r2 = f1;
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f0 = r3;
+                    r29 = r29 + 48;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x328f0:
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x32908;
+                    pc=0x35c00;
+                    run_35c00(); return;
+                case 0x32908:
+                    r5 = f0;
+                    r4 = f1;
+                    r3 = r5 + r0;
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r6 = 32768 << 16;
+                    f0 = r3;
+                    r2 = r4 ^ r6;
+                    f1 = r2;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32934:
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x32950;
+                    pc=0x36e00;
+                    run_36e00(); return;
+                case 0x32950:
+                    /* Next insn is delay slot */ 
+                    pc=0x32908;
+                    continue;
+                case 0x32958:
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x32970;
+                    pc=0x35c00;
+                    run_35c00(); return;
+                case 0x32970:
+                    r3 = f0;
+                    r2 = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x32848;
+                    continue;
+                case 0x32a00:
+                    pc=0x32a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_32a00() throws ExecutionException { /* 0x32a00 - 0x32c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x32a00:
+                    r3 = f12;
+                    r4 = f13;
+                    r5 = 32767 << 16;
+                    r5 = r5 | 65535;
+                    f0 = r3;
+                    r2 = r5 & r4;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32c00:
+                    pc=0x32c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_32c00() throws ExecutionException { /* 0x32c00 - 0x32e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x32c00:
+                    r2 = f13;
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r2 = r3 & r2;
+                    r3 = 16361 << 16;
+                    r3 = r3 + 8700;
+                    r29 = r29 + -48;
+                    r3 = r2 < r3 ? 1 : 0;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32cd4;
+                        continue;
+                    }
+                    r3 = 32752 << 16;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32c60;
+                        continue;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = f2;
+                    r2 = f3;
+                case 0x32c48:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f0 = r3;
+                    r29 = r29 + 48;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32c60:
+                    r6 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x32c6c;
+                    pc=0x35200;
+                    run_35200(); return;
+                case 0x32c6c:
+                    r2 = r2 & 3;
+                    r3 = r0 + 1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32d2c;
+                        continue;
+                    }
+                    r4 = r0 + 2;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32d08;
+                        continue;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32d54;
+                        continue;
+                    }
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x32ca8;
+                    pc=0x35c00;
+                    run_35c00(); return;
+                case 0x32ca8:
+                    r5 = f0;
+                    r4 = f1;
+                    r3 = r5 + r0;
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r6 = 32768 << 16;
+                    f0 = r3;
+                    r2 = r4 ^ r6;
+                    f1 = r2;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32cd4:
+                    f14 = r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r0;
+                    f15 = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x32ce8;
+                    pc=0x36e00;
+                    run_36e00(); return;
+                case 0x32ce8:
+                    r3 = f0;
+                    r2 = f1;
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f0 = r3;
+                    r29 = r29 + 48;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32d08:
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x32d24;
+                    pc=0x36e00;
+                    run_36e00(); return;
+                case 0x32d24:
+                    /* Next insn is delay slot */ 
+                    pc=0x32ca8;
+                    continue;
+                case 0x32d2c:
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x32d44;
+                    pc=0x35c00;
+                    run_35c00(); return;
+                case 0x32d44:
+                    r3 = f0;
+                    r2 = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x32c48;
+                    continue;
+                case 0x32d54:
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x32d70;
+                    pc=0x36e00;
+                    run_36e00(); return;
+                case 0x32d70:
+                    r3 = f0;
+                    r2 = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x32c48;
+                    continue;
+                case 0x32e00:
+                    pc=0x32e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_32e00() throws ExecutionException { /* 0x32e00 - 0x33000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x32e00:
+                    r2 = f13;
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r2 = r3 & r2;
+                    r3 = 16361 << 16;
+                    r3 = r3 + 8700;
+                    r29 = r29 + -48;
+                    r3 = r2 < r3 ? 1 : 0;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32e98;
+                        continue;
+                    }
+                    r3 = 32752 << 16;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x32e50;
+                        continue;
+                    }
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32e50:
+                    r6 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x32e5c;
+                    pc=0x35200;
+                    run_35200(); return;
+                case 0x32e5c:
+                    r2 = r2 & 1;
+                    f12 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f14 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    r2 = r2 << 1;
+                    r2 = r3 - r2;
+                    f13 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f15 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x32e88;
+                    pc=0x37000;
+                    run_37000(); return;
+                case 0x32e88:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x32e98:
+                    f14 = r0;
+                    r2 = r0 + 1;
+                    f15 = r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x32eb0;
+                    pc=0x37000;
+                    run_37000(); return;
+                case 0x32eb0:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33000:
+                    pc=0x33000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_33000() throws ExecutionException { /* 0x33000 - 0x33200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x33000:
+                    r29 = r29 + -80;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = f22;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = f23;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f20;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f21;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    f20 = f12;
+                    f21 = f13;
+                    /* Next insn is delay slot */ 
+                    r31=0x33024;
+                    pc=0x33a00;
+                    run_33a00(); return;
+                case 0x33024:
+                    r3 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    f22 = f0;
+                    f23 = f1;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3304c;
+                        continue;
+                    }
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x33044;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x33044:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33070;
+                        continue;
+                    }
+                case 0x3304c:
+                    f20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    f0 = f22;
+                    f1 = f23;
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f22 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    f21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    f23 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r29 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33070:
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x3307c;
+                    pc=0x32a00;
+                    run_32a00(); return;
+                case 0x3307c:
+                    f2 = readPages[(r28+-32076)>>>12][((r28+-32076)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-32080)>>>12][((r28+-32080)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3304c;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = 7 << 16;
+                    r2 = 7 << 16;
+                    r2 = r2 + -352;
+                    r4 = r4 + -12264;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f20;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x330d4;
+                    pc=0x37e00;
+                    run_37e00(); return;
+                case 0x330d4:
+                    r3 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33138;
+                        continue;
+                    }
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x330f8;
+                    pc=0x37c00;
+                    run_37c00(); return;
+                case 0x330f8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33138;
+                        continue;
+                    }
+                case 0x33100:
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33150;
+                        continue;
+                    }
+                case 0x33110:
+                    f0 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f22 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    f20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f1 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    f23 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    f21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r29 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33138:
+                    /* Next insn is delay slot */ 
+                    r31=0x33140;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x33140:
+                    r3 = r0 + 33;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x33100;
+                    continue;
+                case 0x33150:
+                    /* Next insn is delay slot */ 
+                    r31=0x33158;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x33158:
+                    r3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x33110;
+                    continue;
+                case 0x33200:
+                    pc=0x33200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_33200() throws ExecutionException { /* 0x33200 - 0x33400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x33200:
+                    r29 = r29 + -80;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = f22;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = f23;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f20;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f21;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    f20 = f12;
+                    f21 = f13;
+                    /* Next insn is delay slot */ 
+                    r31=0x33224;
+                    pc=0x34000;
+                    run_34000(); return;
+                case 0x33224:
+                    r3 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    f22 = f0;
+                    f23 = f1;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3324c;
+                        continue;
+                    }
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x33244;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x33244:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33270;
+                        continue;
+                    }
+                case 0x3324c:
+                    f20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    f0 = f22;
+                    f1 = f23;
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f22 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    f21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    f23 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r29 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33270:
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x3327c;
+                    pc=0x32a00;
+                    run_32a00(); return;
+                case 0x3327c:
+                    f2 = readPages[(r28+-32068)>>>12][((r28+-32068)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-32072)>>>12][((r28+-32072)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3324c;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = 7 << 16;
+                    r2 = 7 << 16;
+                    r2 = r2 + -344;
+                    r4 = r4 + -12264;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f20;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x332d4;
+                    pc=0x37e00;
+                    run_37e00(); return;
+                case 0x332d4:
+                    r3 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33338;
+                        continue;
+                    }
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x332f8;
+                    pc=0x37c00;
+                    run_37c00(); return;
+                case 0x332f8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33338;
+                        continue;
+                    }
+                case 0x33300:
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33350;
+                        continue;
+                    }
+                case 0x33310:
+                    f0 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f22 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    f20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f1 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    f23 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    f21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r29 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33338:
+                    /* Next insn is delay slot */ 
+                    r31=0x33340;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x33340:
+                    r3 = r0 + 33;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x33300;
+                    continue;
+                case 0x33350:
+                    /* Next insn is delay slot */ 
+                    r31=0x33358;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x33358:
+                    r3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x33310;
+                    continue;
+                case 0x33400:
+                    pc=0x33400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_33400() throws ExecutionException { /* 0x33400 - 0x33600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x33400:
+                    r29 = r29 + -96;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r16;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = f24;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = f25;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = f22;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = f23;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f20;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f21;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = f26;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = f27;
+                    f24 = f12;
+                    f25 = f13;
+                    f20 = f14;
+                    f21 = f15;
+                    /* Next insn is delay slot */ 
+                    r31=0x3343c;
+                    pc=0x34600;
+                    run_34600(); return;
+                case 0x3343c:
+                    r2 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    r16 = r0 + -1;
+                    f22 = f0;
+                    f23 = f1;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33464;
+                        continue;
+                    }
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x3345c;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x3345c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3349c;
+                        continue;
+                    }
+                case 0x33464:
+                    f0 = f22;
+                    f1 = f23;
+                case 0x33468:
+                    f26 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    f24 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    f22 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    f20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r16 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    f27 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    f25 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    f23 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    f21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r29 = r29 + 96;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3349c:
+                    f12 = f24;
+                    f13 = f25;
+                    /* Next insn is delay slot */ 
+                    r31=0x334a8;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x334a8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3356c;
+                        continue;
+                    }
+                    f0 = r0;
+                    f1 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33464;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    f0 = readPages[(r28+-32060)>>>12][((r28+-32060)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r2 = r2 + -336;
+                    f1 = readPages[(r28+-32064)>>>12][((r28+-32064)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f24;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f25;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33558;
+                        continue;
+                    }
+                    r3 = r0 + 2;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33558;
+                        continue;
+                    }
+                case 0x33520:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x3352c;
+                    pc=0x37c00;
+                    run_37c00(); return;
+                case 0x3352c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33750;
+                        run_33600(); return;
+                    }
+                case 0x33534:
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33558;
+                        continue;
+                    }
+                case 0x33544:
+                    /* Next insn is delay slot */ 
+                    r31=0x3354c;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x3354c:
+                    r3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                case 0x33558:
+                    f0 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f1 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x33468;
+                    continue;
+                case 0x3356c:
+                    f26 = r0;
+                    f27 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))==(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x335f8;
+                        continue;
+                    }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))==(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x336c0;
+                        run_33600(); return;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + -336;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f24;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f25;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f26;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f27;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33520;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-32060)>>>12][((r28+-32060)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32064)>>>12][((r28+-32064)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x33558;
+                    continue;
+                case 0x335f8:
+                    f12 = f22;
+                    f13 = f23;
+                    /* Next insn is delay slot */ 
+                    r31=0x33604;
+                    pc=0x37400;
+                    run_37400(); return;
+                case 0x33600:
+                    pc=0x33600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_33600() throws ExecutionException { /* 0x33600 - 0x33800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x33600:
+                case 0x33604:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33768;
+                        continue;
+                    }
+                case 0x3360c:
+                    f26 = r0;
+                    f27 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))==(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33464;
+                        run_33400(); return;
+                    }
+                    f12 = f24;
+                    f13 = f25;
+                    /* Next insn is delay slot */ 
+                    r31=0x33638;
+                    pc=0x37400;
+                    run_37400(); return;
+                case 0x33638:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33464;
+                        run_33400(); return;
+                    }
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x3364c;
+                    pc=0x37400;
+                    run_37400(); return;
+                case 0x3364c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33464;
+                        run_33400(); return;
+                    }
+                    r2 = r0 + 4;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + -336;
+                    r3 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f24;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f25;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f26;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f27;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3387c;
+                        run_33800(); return;
+                    }
+                case 0x33694:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x336a0;
+                    pc=0x37c00;
+                    run_37c00(); return;
+                case 0x336a0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3387c;
+                        run_33800(); return;
+                    }
+                case 0x336a8:
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33558;
+                        run_33400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x33544;
+                    run_33400(); return;
+                case 0x336c0:
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x336cc;
+                    pc=0x37400;
+                    run_37400(); return;
+                case 0x336cc:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33464;
+                        run_33400(); return;
+                    }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))<(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33464;
+                        run_33400(); return;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + -336;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f24;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f25;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3380c;
+                        run_33800(); return;
+                    }
+                    f0 = readPages[(r28+-32052)>>>12][((r28+-32052)>>>2)&0x3ff];
+                    r3 = r0 + 2;
+                    f1 = readPages[(r28+-32056)>>>12][((r28+-32056)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x337f0;
+                        continue;
+                    }
+                case 0x33738:
+                    /* Next insn is delay slot */ 
+                    r31=0x33740;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x33740:
+                    r3 = r0 + 33;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x336a8;
+                    continue;
+                case 0x33750:
+                    /* Next insn is delay slot */ 
+                    r31=0x33758;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x33758:
+                    r3 = r0 + 33;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x33534;
+                    run_33400(); return;
+                case 0x33768:
+                    f12 = f24;
+                    f13 = f25;
+                    /* Next insn is delay slot */ 
+                    r31=0x33774;
+                    pc=0x37400;
+                    run_37400(); return;
+                case 0x33774:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3360c;
+                        continue;
+                    }
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x33788;
+                    pc=0x37400;
+                    run_37400(); return;
+                case 0x33788:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3360c;
+                        continue;
+                    }
+                    f12 = f22;
+                    f13 = f23;
+                    /* Next insn is delay slot */ 
+                    r31=0x3379c;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x3379c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3381c;
+                        run_33800(); return;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + -336;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f24;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f25;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3380c;
+                        run_33800(); return;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))/(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))); f27 = (int)(l >>> 32); f26 = (int)l; }
+                    r3 = r0 + 2;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f26;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f27;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33738;
+                        continue;
+                    }
+                case 0x337f0:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x337fc;
+                    pc=0x37c00;
+                    run_37c00(); return;
+                case 0x337fc:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x336a8;
+                        continue;
+                    }
+                case 0x33800:
+                    pc=0x33800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_33800() throws ExecutionException { /* 0x33800 - 0x33a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x33800:
+                    /* Next insn is delay slot */ 
+                    pc=0x33738;
+                    run_33600(); return;
+                case 0x3380c:
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f26;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f27;
+                    /* Next insn is delay slot */ 
+                    pc=0x337f0;
+                    run_33600(); return;
+                case 0x3381c:
+                    r2 = r0 + 3;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + -336;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f24;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f25;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33894;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-32044)>>>12][((r28+-32044)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))<(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    f1 = readPages[(r28+-32048)>>>12][((r28+-32048)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33908;
+                        continue;
+                    }
+                case 0x33870:
+                    r3 = r0 + 2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33694;
+                        run_33600(); return;
+                    }
+                case 0x3387c:
+                    /* Next insn is delay slot */ 
+                    r31=0x33884;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x33884:
+                    r3 = r0 + 34;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x336a8;
+                    run_33600(); return;
+                case 0x33894:
+                    f0 = readPages[(r28+-32020)>>>12][((r28+-32020)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))<(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    f1 = readPages[(r28+-32024)>>>12][((r28+-32024)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33870;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-32036)>>>12][((r28+-32036)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32040)>>>12][((r28+-32040)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x338d4;
+                    pc=0x38000;
+                    run_38000(); return;
+                case 0x338d4:
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))==(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x338fc;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-32052)>>>12][((r28+-32052)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32056)>>>12][((r28+-32056)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                case 0x338fc:
+                    r2 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x33870;
+                    continue;
+                case 0x33908:
+                    f0 = readPages[(r28+-32036)>>>12][((r28+-32036)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32040)>>>12][((r28+-32040)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x33928;
+                    pc=0x38000;
+                    run_38000(); return;
+                case 0x33928:
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))==(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x338fc;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-32028)>>>12][((r28+-32028)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-31120)>>>12][((r28+-31120)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32032)>>>12][((r28+-32032)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x33870;
+                    continue;
+                case 0x33a00:
+                    pc=0x33a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_33a00() throws ExecutionException { /* 0x33a00 - 0x33c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x33a00:
+                    r2 = f13;
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r6 = r2 + r0;
+                    r2 = r3 & r2;
+                    r3 = 16368 << 16;
+                    r29 = r29 + -48;
+                    r4 = r2 < r3 ? 1 : 0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f24;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f25;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f22;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f23;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f20;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f21;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33a94;
+                        continue;
+                    }
+                    r5 = f12;
+                    r2 = r2 - r3;
+                    r2 = r2 | r5;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33c24;
+                        run_33c00(); return;
+                    }
+                    if(r6 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33d6c;
+                        run_33c00(); return;
+                    }
+                    f0 = r0;
+                    f1 = r0;
+                case 0x33a6c:
+                    f24 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f22 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f25 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    f23 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33a94:
+                    r3 = 16352 << 16;
+                    r3 = r2 < r3 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33be0;
+                        continue;
+                    }
+                    if(r6 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33d80;
+                        run_33c00(); return;
+                    }
+                    f22 = readPages[(r28+-31916)>>>12][((r28+-31916)>>>2)&0x3ff];
+                    f0 = readPages[(r28+-31900)>>>12][((r28+-31900)>>>2)&0x3ff];
+                    f23 = readPages[(r28+-31920)>>>12][((r28+-31920)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31904)>>>12][((r28+-31904)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x33ad0;
+                    pc=0x35800;
+                    run_35800(); return;
+                case 0x33ad0:
+                    f12 = readPages[(r28+-31996)>>>12][((r28+-31996)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-31988)>>>12][((r28+-31988)>>>2)&0x3ff];
+                    f13 = readPages[(r28+-32000)>>>12][((r28+-32000)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31992)>>>12][((r28+-31992)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f6 = readPages[(r28+-31940)>>>12][((r28+-31940)>>>2)&0x3ff];
+                    r3 = r0 + r0;
+                    f7 = readPages[(r28+-31944)>>>12][((r28+-31944)>>>2)&0x3ff];
+                    r2 = f1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f4 = readPages[(r28+-31980)>>>12][((r28+-31980)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f5 = readPages[(r28+-31984)>>>12][((r28+-31984)>>>2)&0x3ff];
+                    f2 = r3;
+                    f24 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f3 = r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f4 = readPages[(r28+-31972)>>>12][((r28+-31972)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f5 = readPages[(r28+-31976)>>>12][((r28+-31976)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f25 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f4 = readPages[(r28+-31964)>>>12][((r28+-31964)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f5 = readPages[(r28+-31968)>>>12][((r28+-31968)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f4 = readPages[(r28+-31956)>>>12][((r28+-31956)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f5 = readPages[(r28+-31960)>>>12][((r28+-31960)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f4 = readPages[(r28+-31948)>>>12][((r28+-31948)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f5 = readPages[(r28+-31952)>>>12][((r28+-31952)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-31932)>>>12][((r28+-31932)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f7 = readPages[(r28+-31936)>>>12][((r28+-31936)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-31924)>>>12][((r28+-31924)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f7 = readPages[(r28+-31928)>>>12][((r28+-31928)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))/(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f22 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f23 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33be0:
+                    r3 = 15456 << 16;
+                    r3 = r3 + 1;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x33c54;
+                        run_33c00(); return;
+                    }
+                    f24 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f22 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                case 0x33c00:
+                    pc=0x33c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_33c00() throws ExecutionException { /* 0x33c00 - 0x33e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x33c00:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f0 = readPages[(r28+-32004)>>>12][((r28+-32004)>>>2)&0x3ff];
+                    f25 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    f23 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32008)>>>12][((r28+-32008)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33c24:
+                    f24 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f22 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f25 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    f23 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))/(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33c54:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f0 = readPages[(r28+-31996)>>>12][((r28+-31996)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-31988)>>>12][((r28+-31988)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32000)>>>12][((r28+-32000)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31992)>>>12][((r28+-31992)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f6 = readPages[(r28+-31940)>>>12][((r28+-31940)>>>2)&0x3ff];
+                    f24 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f7 = readPages[(r28+-31944)>>>12][((r28+-31944)>>>2)&0x3ff];
+                    f22 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f4 = readPages[(r28+-31980)>>>12][((r28+-31980)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f5 = readPages[(r28+-31984)>>>12][((r28+-31984)>>>2)&0x3ff];
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f25 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f4 = readPages[(r28+-31972)>>>12][((r28+-31972)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f5 = readPages[(r28+-31976)>>>12][((r28+-31976)>>>2)&0x3ff];
+                    f23 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f4 = readPages[(r28+-31964)>>>12][((r28+-31964)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f5 = readPages[(r28+-31968)>>>12][((r28+-31968)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f4 = readPages[(r28+-31956)>>>12][((r28+-31956)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f5 = readPages[(r28+-31960)>>>12][((r28+-31960)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f4 = readPages[(r28+-31948)>>>12][((r28+-31948)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f5 = readPages[(r28+-31952)>>>12][((r28+-31952)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-31932)>>>12][((r28+-31932)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f7 = readPages[(r28+-31936)>>>12][((r28+-31936)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-31924)>>>12][((r28+-31924)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f7 = readPages[(r28+-31928)>>>12][((r28+-31928)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31916)>>>12][((r28+-31916)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31920)>>>12][((r28+-31920)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31908)>>>12][((r28+-31908)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31912)>>>12][((r28+-31912)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f0 = readPages[(r28+-32004)>>>12][((r28+-32004)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32008)>>>12][((r28+-32008)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x33d6c:
+                    f0 = readPages[(r28+-32012)>>>12][((r28+-32012)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-32016)>>>12][((r28+-32016)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x33a6c;
+                    run_33a00(); return;
+                case 0x33d80:
+                    f24 = readPages[(r28+-31916)>>>12][((r28+-31916)>>>2)&0x3ff];
+                    f0 = readPages[(r28+-31900)>>>12][((r28+-31900)>>>2)&0x3ff];
+                    f25 = readPages[(r28+-31920)>>>12][((r28+-31920)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31904)>>>12][((r28+-31904)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f20 = readPages[(r28+-31996)>>>12][((r28+-31996)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    f21 = readPages[(r28+-32000)>>>12][((r28+-32000)>>>2)&0x3ff];
+                    f0 = readPages[(r28+-31988)>>>12][((r28+-31988)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-31964)>>>12][((r28+-31964)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31992)>>>12][((r28+-31992)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f3 = readPages[(r28+-31968)>>>12][((r28+-31968)>>>2)&0x3ff];
+                    f12 = f22;
+                    f13 = f23;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f0 = readPages[(r28+-31980)>>>12][((r28+-31980)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f1 = readPages[(r28+-31984)>>>12][((r28+-31984)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f0 = readPages[(r28+-31972)>>>12][((r28+-31972)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f1 = readPages[(r28+-31976)>>>12][((r28+-31976)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f2 = readPages[(r28+-31956)>>>12][((r28+-31956)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f3 = readPages[(r28+-31960)>>>12][((r28+-31960)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                case 0x33e00:
+                    pc=0x33e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_33e00() throws ExecutionException { /* 0x33e00 - 0x34000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x33e00:
+                    /* Next insn is delay slot */ 
+                    r31=0x33e08;
+                    pc=0x35800;
+                    run_35800(); return;
+                case 0x33e08:
+                    f12 = readPages[(r28+-31948)>>>12][((r28+-31948)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-31940)>>>12][((r28+-31940)>>>2)&0x3ff];
+                    f13 = readPages[(r28+-31952)>>>12][((r28+-31952)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31944)>>>12][((r28+-31944)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f2 = readPages[(r28+-31932)>>>12][((r28+-31932)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f3 = readPages[(r28+-31936)>>>12][((r28+-31936)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f2 = readPages[(r28+-31924)>>>12][((r28+-31924)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f3 = readPages[(r28+-31928)>>>12][((r28+-31928)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f2 = readPages[(r28+-31908)>>>12][((r28+-31908)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    f3 = readPages[(r28+-31912)>>>12][((r28+-31912)>>>2)&0x3ff];
+                    f12 = readPages[(r28+-32012)>>>12][((r28+-32012)>>>2)&0x3ff];
+                    f13 = readPages[(r28+-32016)>>>12][((r28+-32016)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))+(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))/(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x33a6c;
+                    run_33a00(); return;
+                case 0x34000:
+                    pc=0x34000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_34000() throws ExecutionException { /* 0x34000 - 0x34200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x34000:
+                    r29 = r29 + -56;
+                    r2 = f13;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = 32767 << 16;
+                    r16 = r16 | 65535;
+                    r16 = r16 & r2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r17 = r2 + r0;
+                    r2 = 16368 << 16;
+                    r3 = r16 < r2 ? 1 : 0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f24;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f25;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f22;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f23;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f21;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x340a8;
+                        continue;
+                    }
+                    r5 = f12;
+                    r2 = r16 - r2;
+                    r2 = r2 | r5;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x340fc;
+                        continue;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))/(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = f2;
+                    r2 = f3;
+                case 0x34070:
+                    f24 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    f22 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f0 = r3;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f25 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    f23 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    f21 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    f1 = r2;
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x340a8:
+                    r2 = 16352 << 16;
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34138;
+                        continue;
+                    }
+                    r2 = 15936 << 16;
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x342e8;
+                        run_34200(); return;
+                    }
+                    f0 = readPages[(r28+-31876)>>>12][((r28+-31876)>>>2)&0x3ff];
+                    f22 = readPages[(r28+-31868)>>>12][((r28+-31868)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31880)>>>12][((r28+-31880)>>>2)&0x3ff];
+                    f23 = readPages[(r28+-31872)>>>12][((r28+-31872)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34144;
+                        continue;
+                    }
+                    r3 = f12;
+                    r2 = f13;
+                    /* Next insn is delay slot */ 
+                    pc=0x34070;
+                    continue;
+                case 0x340fc:
+                    f0 = readPages[(r28+-31892)>>>12][((r28+-31892)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31896)>>>12][((r28+-31896)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f0 = readPages[(r28+-31884)>>>12][((r28+-31884)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31888)>>>12][((r28+-31888)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r3 = f0;
+                    r2 = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x34070;
+                    continue;
+                case 0x34138:
+                    f22 = readPages[(r28+-31868)>>>12][((r28+-31868)>>>2)&0x3ff];
+                    f23 = readPages[(r28+-31872)>>>12][((r28+-31872)>>>2)&0x3ff];
+                case 0x34144:
+                    /* Next insn is delay slot */ 
+                    r31=0x3414c;
+                    pc=0x32a00;
+                    run_32a00(); return;
+                case 0x3414c:
+                    f2 = readPages[(r28+-31780)>>>12][((r28+-31780)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f3 = readPages[(r28+-31784)>>>12][((r28+-31784)>>>2)&0x3ff];
+                    f24 = readPages[(r28+-31860)>>>12][((r28+-31860)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f25 = readPages[(r28+-31864)>>>12][((r28+-31864)>>>2)&0x3ff];
+                    f0 = readPages[(r28+-31852)>>>12][((r28+-31852)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-31828)>>>12][((r28+-31828)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31856)>>>12][((r28+-31856)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f3 = readPages[(r28+-31832)>>>12][((r28+-31832)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-31820)>>>12][((r28+-31820)>>>2)&0x3ff];
+                    f12 = f20;
+                    f13 = f21;
+                    f5 = readPages[(r28+-31824)>>>12][((r28+-31824)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f0 = readPages[(r28+-31844)>>>12][((r28+-31844)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f1 = readPages[(r28+-31848)>>>12][((r28+-31848)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f0 = readPages[(r28+-31836)>>>12][((r28+-31836)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f1 = readPages[(r28+-31840)>>>12][((r28+-31840)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f0 = readPages[(r28+-31812)>>>12][((r28+-31812)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f1 = readPages[(r28+-31816)>>>12][((r28+-31816)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f2 = readPages[(r28+-31804)>>>12][((r28+-31804)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    f3 = readPages[(r28+-31808)>>>12][((r28+-31808)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31796)>>>12][((r28+-31796)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f3 = readPages[(r28+-31800)>>>12][((r28+-31800)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f25 = (int)(l >>> 32); f24 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31788)>>>12][((r28+-31788)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f3 = readPages[(r28+-31792)>>>12][((r28+-31792)>>>2)&0x3ff];
+                case 0x34200:
+                    pc=0x34200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_34200() throws ExecutionException { /* 0x34200 - 0x34400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x34200:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    r31=0x34218;
+                    pc=0x35800;
+                    run_35800(); return;
+                case 0x34218:
+                    r2 = 16367 << 16;
+                    r2 = r2 + 13107;
+                    r16 = r16 < r2 ? 1 : 0;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34274;
+                        continue;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))/(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    f4 = readPages[(r28+-31884)>>>12][((r28+-31884)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-31892)>>>12][((r28+-31892)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31888)>>>12][((r28+-31888)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31896)>>>12][((r28+-31896)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r5 = f4;
+                    r4 = f5;
+                case 0x3425c:
+                    if(r17 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x343f0;
+                        continue;
+                    }
+                    r3 = r5 + r0;
+                    r2 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x34070;
+                    run_34000(); return;
+                case 0x34274:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))/(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    r3 = r0 + r0;
+                    r2 = f1;
+                    f2 = r3;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f3 = r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f23 = (int)(l >>> 32); f22 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))-(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f22 = readPages[(r28+-31884)>>>12][((r28+-31884)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    f23 = readPages[(r28+-31888)>>>12][((r28+-31888)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))+(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))-(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f21 = (int)(l >>> 32); f20 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f4 = readPages[(r28+-31772)>>>12][((r28+-31772)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31776)>>>12][((r28+-31776)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r5 = f2;
+                    r4 = f3;
+                    /* Next insn is delay slot */ 
+                    pc=0x3425c;
+                    continue;
+                case 0x342e8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31860)>>>12][((r28+-31860)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31864)>>>12][((r28+-31864)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = readPages[(r28+-31852)>>>12][((r28+-31852)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31856)>>>12][((r28+-31856)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = readPages[(r28+-31844)>>>12][((r28+-31844)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31848)>>>12][((r28+-31848)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = readPages[(r28+-31836)>>>12][((r28+-31836)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31840)>>>12][((r28+-31840)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = readPages[(r28+-31828)>>>12][((r28+-31828)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31832)>>>12][((r28+-31832)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = readPages[(r28+-31820)>>>12][((r28+-31820)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31824)>>>12][((r28+-31824)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31804)>>>12][((r28+-31804)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f2 = readPages[(r28+-31812)>>>12][((r28+-31812)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31808)>>>12][((r28+-31808)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31816)>>>12][((r28+-31816)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31796)>>>12][((r28+-31796)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31800)>>>12][((r28+-31800)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31788)>>>12][((r28+-31788)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31792)>>>12][((r28+-31792)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31868)>>>12][((r28+-31868)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31872)>>>12][((r28+-31872)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r3 = f4;
+                    r2 = f5;
+                    /* Next insn is delay slot */ 
+                    pc=0x34070;
+                    run_34000(); return;
+                case 0x343f0:
+                    r6 = 32768 << 16;
+                    r2 = r4 ^ r6;
+                    r3 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x34070;
+                    run_34000(); return;
+                case 0x34400:
+                    pc=0x34400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_34400() throws ExecutionException { /* 0x34400 - 0x34600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x34400:
+                case 0x34600:
+                    pc=0x34600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_34600() throws ExecutionException { /* 0x34600 - 0x34800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x34600:
+                    r2 = f15;
+                    r4 = 32767 << 16;
+                    r29 = r29 + -72;
+                    r3 = f14;
+                    r4 = r4 | 65535;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r21;
+                    r21 = r4 & r2;
+                    r5 = r21 | r3;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f20;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f21;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r30;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r23;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r22;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    f20 = f12;
+                    f21 = f13;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = f14;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = f15;
+                    r19 = f12;
+                    r18 = f13;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x346c0;
+                        continue;
+                    }
+                    r22 = r4 & r18;
+                    r4 = 32752 << 16;
+                    r5 = r4 + 1;
+                    r5 = r22 < r5 ? 1 : 0;
+                    r16 = r18 + r0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x346ac;
+                        continue;
+                    }
+                    r23 = r19 + r0;
+                    r30 = r2 + r0;
+                    r6 = r3 + r0;
+                    if(r22 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x347e0;
+                        continue;
+                    }
+                case 0x34698:
+                    r4 = 32752 << 16;
+                    r5 = r4 + 1;
+                    r5 = r21 < r5 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3474c;
+                        continue;
+                    }
+                case 0x346ac:
+                    r4 = 49168 << 16;
+                    r22 = r22 + r4;
+                    r22 = r22 | r19;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34708;
+                        continue;
+                    }
+                case 0x346c0:
+                    f0 = readPages[(r28+-31764)>>>12][((r28+-31764)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31768)>>>12][((r28+-31768)>>>2)&0x3ff];
+                case 0x346cc:
+                    f20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r29 = r29 + 72;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x34708:
+                    f20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r4 = 7 << 16;
+                    r4 = r4 + -12264;
+                    r29 = r29 + 72;
+                    /* Next insn is delay slot */ 
+                    pc=0x37e00;
+                    run_37e00(); return;
+                case 0x3474c:
+                    if(r21 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34878;
+                        run_34800(); return;
+                    }
+                case 0x34754:
+                    if(r16 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x348cc;
+                        run_34800(); return;
+                    }
+                case 0x3475c:
+                    r20 = r0 + r0;
+                case 0x34760:
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x347f4;
+                        continue;
+                    }
+                    r2 = 32752 << 16;
+                    if(r21 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34988;
+                        run_34800(); return;
+                    }
+                case 0x34774:
+                    r2 = 16368 << 16;
+                    if(r21 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34928;
+                        run_34800(); return;
+                    }
+                    r2 = 16384 << 16;
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34ed8;
+                        run_34e00(); return;
+                    }
+                    r2 = 16352 << 16;
+                    if(r30 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x347f4;
+                        continue;
+                    }
+                    if(r16 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x347f4;
+                        continue;
+                    }
+                    f12 = f20;
+                    f13 = f21;
+                    f20 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r29 = r29 + 72;
+                    /* Next insn is delay slot */ 
+                    pc=0x35800;
+                    run_35800(); return;
+                case 0x347e0:
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x346ac;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x34698;
+                    continue;
+                case 0x347f0:
+                    r20 = r0 + r0;
+                case 0x347f4:
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x34800;
+                    pc=0x32a00;
+                    run_32a00(); return;
+                case 0x34800:
+                    pc=0x34800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_34800() throws ExecutionException { /* 0x34800 - 0x34a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x34800:
+                    r3 = f0;
+                    r2 = f1;
+                    if(r23 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34888;
+                        continue;
+                    }
+                case 0x34810:
+                    r18 = r18 >>> 31;
+                    r18 = r18 + -1;
+                    r4 = r20 | r18;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x349d4;
+                        continue;
+                    }
+                    r4 = 16864 << 16;
+                    r4 = r4 + 1;
+                    r4 = r21 < r4 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x349e4;
+                        continue;
+                    }
+                    r4 = 17392 << 16;
+                    r4 = r4 + 1;
+                    r21 = r21 < r4 ? 1 : 0;
+                    if(r21 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34f80;
+                        run_34e00(); return;
+                    }
+                    r2 = 16368 << 16;
+                    r22 = r22 < r2 ? 1 : 0;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34964;
+                        continue;
+                    }
+                case 0x3485c:
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3496c;
+                        continue;
+                    }
+                case 0x34864:
+                    f0 = r0;
+                    f1 = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x34878:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34754;
+                        run_34600(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x346ac;
+                    run_34600(); return;
+                case 0x34888:
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x348a8;
+                        continue;
+                    }
+                    r5 = 16383 << 16;
+                    r5 = r5 | 65535;
+                    r5 = r5 & r18;
+                    r4 = 16368 << 16;
+                    if(r5 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34810;
+                        continue;
+                    }
+                case 0x348a8:
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3493c;
+                        continue;
+                    }
+                case 0x348b0:
+                    if(r16 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34ea0;
+                        run_34e00(); return;
+                    }
+                case 0x348b8:
+                    f0 = r3;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x348cc:
+                    r4 = 17216 << 16;
+                    r4 = r21 < r4 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x349c8;
+                        continue;
+                    }
+                    r4 = 16368 << 16;
+                    r4 = r21 < r4 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3475c;
+                        run_34600(); return;
+                    }
+                    r4 = r21 >> 20;
+                    r5 = r4 < 1044 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x350bc;
+                        run_35000(); return;
+                    }
+                    r2 = r0 + 1075;
+                    r4 = r2 - r4;
+                    r2 = r3 >>> (r4&0x1f);
+                    r4 = r2 << (r4&0x1f);
+                    if(r4 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3475c;
+                        run_34600(); return;
+                    }
+                    r2 = r2 & 1;
+                    r20 = r0 + 2;
+                    r20 = r20 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x34760;
+                    run_34600(); return;
+                case 0x34928:
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3505c;
+                        run_35000(); return;
+                    }
+                    f0 = f20;
+                    f1 = f21;
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x3493c:
+                    f2 = r3;
+                    f0 = readPages[(r28+-31764)>>>12][((r28+-31764)>>>2)&0x3ff];
+                    f3 = r2;
+                    f1 = readPages[(r28+-31768)>>>12][((r28+-31768)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = f2;
+                    r2 = f3;
+                    /* Next insn is delay slot */ 
+                    pc=0x348b0;
+                    continue;
+                case 0x34964:
+                    if(r30 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34864;
+                        continue;
+                    }
+                case 0x3496c:
+                    f0 = readPages[(r28+-31748)>>>12][((r28+-31748)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31752)>>>12][((r28+-31752)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x34988:
+                    r2 = 49168 << 16;
+                    r2 = r22 + r2;
+                    r2 = r2 | r19;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x346c0;
+                        run_34600(); return;
+                    }
+                    r2 = 16368 << 16;
+                    r22 = r22 < r2 ? 1 : 0;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34f58;
+                        run_34e00(); return;
+                    }
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34864;
+                        continue;
+                    }
+                    f0 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f1 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x349c8:
+                    r20 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x34760;
+                    run_34600(); return;
+                case 0x349d4:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))-(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x349e4:
+                    r4 = 16 << 16;
+                    r4 = r22 < r4 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35050;
+                        run_35000(); return;
+                    }
+                    f4 = r3;
+                    f0 = readPages[(r28+-31692)>>>12][((r28+-31692)>>>2)&0x3ff];
+                    f5 = r2;
+                case 0x34a00:
+                    pc=0x34a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_34a00() throws ExecutionException { /* 0x34a00 - 0x34c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x34a00:
+                    f1 = readPages[(r28+-31696)>>>12][((r28+-31696)>>>2)&0x3ff];
+                    r4 = r0 + -53;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r2 = f5;
+                    r3 = f4;
+                    r22 = r2 + r0;
+                case 0x34a18:
+                    r8 = r22 >> 20;
+                    r8 = r8 + -1023;
+                    r8 = r8 + r4;
+                    r4 = 15 << 16;
+                    r4 = r4 | 65535;
+                    r22 = r22 & r4;
+                    r4 = 3 << 16;
+                    r4 = r4 | 39055;
+                    r10 = 16368 << 16;
+                    r4 = r22 < r4 ? 1 : 0;
+                    r10 = r22 | r10;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35040;
+                        run_35000(); return;
+                    }
+                    r4 = 11 << 16;
+                    r4 = r4 | 46714;
+                    r22 = r22 < r4 ? 1 : 0;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3510c;
+                        run_35000(); return;
+                    }
+                    r4 = 65520 << 16;
+                    r8 = r8 + 1;
+                    r10 = r10 + r4;
+                    r11 = r0 + r0;
+                    r9 = r0 + r0;
+                case 0x34a74:
+                    r4 = 7 << 16;
+                    r9 = r9 << 3;
+                    r4 = r4 + -296;
+                    r4 = r9 + r4;
+                    f14 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    f16 = r3;
+                    f15 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    f17 = r10;
+                    f12 = readPages[(r28+-31764)>>>12][((r28+-31764)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f17&0xffffffffL) << 32) | (f16&0xffffffffL)))+(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f13 = readPages[(r28+-31768)>>>12][((r28+-31768)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f17&0xffffffffL) << 32) | (f16&0xffffffffL)))-(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r7 = r0 + r0;
+                    f4 = r7;
+                    r7 = r10 >> 1;
+                    r5 = r0 + r0;
+                    f8 = r5;
+                    r5 = r0 + r0;
+                    f18 = readPages[(r28+-31612)>>>12][((r28+-31612)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    f19 = readPages[(r28+-31616)>>>12][((r28+-31616)>>>2)&0x3ff];
+                    r2 = r2 + -328;
+                    r2 = r9 + r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    r6 = f7;
+                    f5 = r6;
+                    r6 = 8192 << 16;
+                    r7 = r7 | r6;
+                    r6 = 8 << 16;
+                    r6 = r7 + r6;
+                    r4 = r6 + r11;
+                    f9 = r4;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f17&0xffffffffL) << 32) | (f16&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f16 = readPages[(r28+-31636)>>>12][((r28+-31636)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f10 = readPages[(r28+-31676)>>>12][((r28+-31676)>>>2)&0x3ff];
+                    f17 = readPages[(r28+-31640)>>>12][((r28+-31640)>>>2)&0x3ff];
+                    f11 = readPages[(r28+-31680)>>>12][((r28+-31680)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f8 = readPages[(r28+-31684)>>>12][((r28+-31684)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f15 = (int)(l >>> 32); f14 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f9 = readPages[(r28+-31688)>>>12][((r28+-31688)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f10 = readPages[(r28+-31668)>>>12][((r28+-31668)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f11 = readPages[(r28+-31672)>>>12][((r28+-31672)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f10 = readPages[(r28+-31660)>>>12][((r28+-31660)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f11 = readPages[(r28+-31664)>>>12][((r28+-31664)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f10 = readPages[(r28+-31652)>>>12][((r28+-31652)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f11 = readPages[(r28+-31656)>>>12][((r28+-31656)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f8 = readPages[(r28+-31644)>>>12][((r28+-31644)>>>2)&0x3ff];
+                    f9 = readPages[(r28+-31648)>>>12][((r28+-31648)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f17&0xffffffffL) << 32) | (f16&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    f8 = r5;
+                    r4 = f11;
+                    r5 = r0 + r0;
+                    f9 = r4;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f17&0xffffffffL) << 32) | (f16&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f16 = readPages[(r28+-31620)>>>12][((r28+-31620)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f17 = readPages[(r28+-31624)>>>12][((r28+-31624)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                case 0x34c00:
+                    pc=0x34c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_34c00() throws ExecutionException { /* 0x34c00 - 0x34e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x34c00:
+                    f10 = r5;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r2 = r2 + -312;
+                    r4 = f1;
+                    f0 = readPages[(r28+-31628)>>>12][((r28+-31628)>>>2)&0x3ff];
+                    f11 = r4;
+                    f1 = readPages[(r28+-31632)>>>12][((r28+-31632)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))*(Double.longBitsToDouble(((f17&0xffffffffL) << 32) | (f16&0xffffffffL)))); f17 = (int)(l >>> 32); f16 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f19&0xffffffffL) << 32) | (f18&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    r9 = r9 + r2;
+                    r5 = r0 + r0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f17&0xffffffffL) << 32) | (f16&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = r8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits(((double)f2)); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    f2 = readPages[(r9+4)>>>12][((r9+4)>>>2)&0x3ff];
+                    f3 = readPages[(r9+0)>>>12][((r9+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    r4 = f9;
+                    f8 = r5;
+                    f9 = r4;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                case 0x34c88:
+                    r20 = r20 + -1;
+                    r18 = r20 | r18;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34f4c;
+                        run_34e00(); return;
+                    }
+                    f20 = readPages[(r28+-31756)>>>12][((r28+-31756)>>>2)&0x3ff];
+                    f21 = readPages[(r28+-31760)>>>12][((r28+-31760)>>>2)&0x3ff];
+                case 0x34ca4:
+                    r5 = r0 + r0;
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    f0 = r5;
+                    f2 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f1 = r4;
+                    f3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = 16528 << 16;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r2 = f1;
+                    r3 = f0;
+                    r5 = r2 < r4 ? 1 : 0;
+                    r7 = r2 + r0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34ee4;
+                        run_34e00(); return;
+                    }
+                    r4 = r2 - r4;
+                    r4 = r4 | r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35078;
+                        run_35000(); return;
+                    }
+                    f2 = readPages[(r28+-31604)>>>12][((r28+-31604)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f3 = readPages[(r28+-31608)>>>12][((r28+-31608)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35078;
+                        run_35000(); return;
+                    }
+                    r5 = r2 + r0;
+                case 0x34d28:
+                    r4 = r5 >> 20;
+                    r3 = 16 << 16;
+                    r4 = r4 + -1022;
+                    r4 = r3 >> (r4&0x1f);
+                    r2 = r4 + r2;
+                    r8 = r2 << 1;
+                    r8 = r8 >>> 21;
+                    r6 = r3 + -1;
+                    r9 = r8 + -1023;
+                    r9 = r6 >> (r9&0x1f);
+                    r9 = ~(r0 | r9);
+                    r4 = r9 & r2;
+                    r5 = r0 + r0;
+                    r2 = r2 & r6;
+                    r3 = r2 | r3;
+                    f0 = r5;
+                    r2 = r0 + 1043;
+                    r8 = r2 - r8;
+                    f1 = r4;
+                    r6 = r3 >> (r8&0x1f);
+                    if(r7 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35130;
+                        run_35000(); return;
+                    }
+                case 0x34d80:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    r4 = r6 << 20;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x34d8c:
+                    r3 = r0 + r0;
+                    r2 = f1;
+                    f0 = r3;
+                    f4 = readPages[(r28+-31588)>>>12][((r28+-31588)>>>2)&0x3ff];
+                    f1 = r2;
+                    f2 = readPages[(r28+-31580)>>>12][((r28+-31580)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f3 = readPages[(r28+-31584)>>>12][((r28+-31584)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    f8 = readPages[(r28+-31572)>>>12][((r28+-31572)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31592)>>>12][((r28+-31592)>>>2)&0x3ff];
+                    f9 = readPages[(r28+-31576)>>>12][((r28+-31576)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f6 = readPages[(r28+-31556)>>>12][((r28+-31556)>>>2)&0x3ff];
+                    f7 = readPages[(r28+-31560)>>>12][((r28+-31560)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    f4 = readPages[(r28+-31564)>>>12][((r28+-31564)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f5 = readPages[(r28+-31568)>>>12][((r28+-31568)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                case 0x34e00:
+                    pc=0x34e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_34e00() throws ExecutionException { /* 0x34e00 - 0x35000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x34e00:
+                    f6 = readPages[(r28+-31548)>>>12][((r28+-31548)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f7 = readPages[(r28+-31552)>>>12][((r28+-31552)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-31540)>>>12][((r28+-31540)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f7 = readPages[(r28+-31544)>>>12][((r28+-31544)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-31532)>>>12][((r28+-31532)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f7 = readPages[(r28+-31536)>>>12][((r28+-31536)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-31524)>>>12][((r28+-31524)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f7 = readPages[(r28+-31528)>>>12][((r28+-31528)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    r2 = f13;
+                    r2 = r4 + r2;
+                    r3 = r2 >> 20;
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3511c;
+                        run_35000(); return;
+                    }
+                    r17 = f12;
+                    f0 = r17;
+                    f1 = r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x34ea0:
+                    r4 = 49168 << 16;
+                    r4 = r22 + r4;
+                    r4 = r20 | r4;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35098;
+                        run_35000(); return;
+                    }
+                    f4 = r3;
+                    f6 = r3;
+                    f5 = r2;
+                    f7 = r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x34ed8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x34ee4:
+                    r5 = 32767 << 16;
+                    r5 = r5 | 65535;
+                    r5 = r5 & r2;
+                    r4 = r4 | 52224;
+                    r4 = r5 < r4 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x350e8;
+                        run_35000(); return;
+                    }
+                    r4 = 16239 << 16;
+                    r4 = r4 + 13312;
+                    r4 = r4 + r2;
+                    r4 = r4 | r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34f2c;
+                        continue;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))<=(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34d28;
+                        run_34c00(); return;
+                    }
+                case 0x34f2c:
+                    f2 = readPages[(r28+-31596)>>>12][((r28+-31596)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31600)>>>12][((r28+-31600)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x34f4c:
+                    f20 = f12;
+                    f21 = f13;
+                    /* Next insn is delay slot */ 
+                    pc=0x34ca4;
+                    run_34c00(); return;
+                case 0x34f58:
+                    if(r30 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34864;
+                        run_34800(); return;
+                    }
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = 32768 << 16;
+                    f0 = r3;
+                    r2 = r5 ^ r4;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x34f80:
+                    r4 = 16367 << 16;
+                    r4 = r4 | 65535;
+                    r5 = r22 < r4 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3485c;
+                        run_34800(); return;
+                    }
+                    r4 = r4 + 2;
+                    r22 = r22 < r4 ? 1 : 0;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34964;
+                        run_34800(); return;
+                    }
+                    f12 = readPages[(r28+-31764)>>>12][((r28+-31764)>>>2)&0x3ff];
+                    f10 = r3;
+                    f13 = readPages[(r28+-31768)>>>12][((r28+-31768)>>>2)&0x3ff];
+                    f11 = r2;
+                    f0 = readPages[(r28+-31724)>>>12][((r28+-31724)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f1 = readPages[(r28+-31728)>>>12][((r28+-31728)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-31716)>>>12][((r28+-31716)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f3 = readPages[(r28+-31720)>>>12][((r28+-31720)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    f6 = readPages[(r28+-31740)>>>12][((r28+-31740)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-31732)>>>12][((r28+-31732)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f7 = readPages[(r28+-31744)>>>12][((r28+-31744)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f0 = readPages[(r28+-31708)>>>12][((r28+-31708)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31736)>>>12][((r28+-31736)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31712)>>>12][((r28+-31712)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x35000:
+                    pc=0x35000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_35000() throws ExecutionException { /* 0x35000 - 0x35200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x35000:
+                    f8 = readPages[(r28+-31700)>>>12][((r28+-31700)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    f9 = readPages[(r28+-31704)>>>12][((r28+-31704)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f8 = r5;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r4 = f3;
+                    f9 = r4;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x34c88;
+                    run_34c00(); return;
+                case 0x35040:
+                    r11 = r0 + r0;
+                    r9 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x34a74;
+                    run_34a00(); return;
+                case 0x35050:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x34a18;
+                    run_34a00(); return;
+                case 0x3505c:
+                    f0 = readPages[(r28+-31764)>>>12][((r28+-31764)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31768)>>>12][((r28+-31768)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x35078:
+                    f2 = readPages[(r28+-31748)>>>12][((r28+-31748)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31752)>>>12][((r28+-31752)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x35098:
+                    r4 = r0 + 1;
+                    if(r20 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x348b8;
+                        run_34800(); return;
+                    }
+                    r6 = 32768 << 16;
+                    f0 = r3;
+                    r4 = r2 ^ r6;
+                    f1 = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x350bc:
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x347f0;
+                        run_34600(); return;
+                    }
+                    r2 = r0 + 1043;
+                    r4 = r2 - r4;
+                    r2 = r21 >> (r4&0x1f);
+                    r4 = r2 << (r4&0x1f);
+                    if(r4 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3513c;
+                        continue;
+                    }
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x34774;
+                    run_34600(); return;
+                case 0x350e8:
+                    r4 = 16352 << 16;
+                    r4 = r4 + 1;
+                    r4 = r5 < r4 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x34d28;
+                        run_34c00(); return;
+                    }
+                    r4 = r0 + r0;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x34d8c;
+                    run_34c00(); return;
+                case 0x3510c:
+                    r11 = 4 << 16;
+                    r9 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x34a74;
+                    run_34a00(); return;
+                case 0x3511c:
+                    /* Next insn is delay slot */ 
+                    r31=0x35124;
+                    pc=0x38400;
+                    run_38400(); return;
+                case 0x35124:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x346cc;
+                    run_34600(); return;
+                case 0x35130:
+                    r6 = r0 - r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x34d80;
+                    run_34c00(); return;
+                case 0x3513c:
+                    r2 = r2 & 1;
+                    r20 = r0 + 2;
+                    r20 = r20 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x34774;
+                    run_34600(); return;
+                case 0x35200:
+                    pc=0x35200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_35200() throws ExecutionException { /* 0x35200 - 0x35400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x35200:
+                    r29 = r29 + -64;
+                    r2 = f13;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r18;
+                    r18 = 32767 << 16;
+                    r18 = r18 | 65535;
+                    r18 = r18 & r2;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r17;
+                    r17 = r2 + r0;
+                    r2 = 16361 << 16;
+                    r2 = r2 + 8700;
+                    r2 = r18 < r2 ? 1 : 0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    r16 = r6 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3542c;
+                        run_35400(); return;
+                    }
+                    r2 = 16386 << 16;
+                    r2 = r2 | 55676;
+                    r2 = r18 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x352c8;
+                        continue;
+                    }
+                    f2 = readPages[(r28+-31516)>>>12][((r28+-31516)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31520)>>>12][((r28+-31520)>>>2)&0x3ff];
+                    if(r17 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35690;
+                        run_35600(); return;
+                    }
+                    r2 = 16377 << 16;
+                    r2 = r2 + 8699;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35478;
+                        run_35400(); return;
+                    }
+                    f2 = readPages[(r28+-31508)>>>12][((r28+-31508)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31512)>>>12][((r28+-31512)>>>2)&0x3ff];
+                case 0x3528c:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r18 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r17 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = f4;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = f5;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = f2;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = f3;
+                    r2 = r0 + 1;
+                    r16 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x352c8:
+                    r2 = 16697 << 16;
+                    r2 = r2 + 8700;
+                    r2 = r18 < r2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35494;
+                        run_35400(); return;
+                    }
+                    r2 = 32752 << 16;
+                    r2 = r18 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3545c;
+                        run_35400(); return;
+                    }
+                    r9 = f12;
+                    r4 = r0 + r0;
+                    f0 = r9;
+                    r6 = r18 >> 20;
+                    f1 = r4;
+                    r6 = r6 + -1046;
+                    r5 = f0;
+                    r2 = r6 << 20;
+                    f2 = r5;
+                    r4 = r18 - r2;
+                    f3 = r4;
+                    r2 = fcsr;
+                    r2 = fcsr;
+                    r1 = r2 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r2;
+                    { long l = Double.doubleToLongBits(((double)f0)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31452)>>>12][((r28+-31452)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31456)>>>12][((r28+-31456)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    { long l = Double.doubleToLongBits(((double)f0)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = r0;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f1;
+                    f3 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))==(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f4;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = f5;
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x356dc;
+                        run_35600(); return;
+                    }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))==(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x356e8;
+                        run_35600(); return;
+                    }
+                    r7 = r0 + 1;
+                case 0x353d8:
+                    r2 = r0 + 2;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + -152;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r4 = r29 + 24;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x353fc;
+                    pc=0x36000;
+                    run_36000(); return;
+                case 0x353fc:
+                    if(r17 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35440;
+                        run_35400(); return;
+                    }
+                case 0x35400:
+                    pc=0x35400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_35400() throws ExecutionException { /* 0x35400 - 0x35600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x35400:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = 32768 << 16;
+                    r4 = r4 ^ r3;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r0 - r2;
+                    r3 = r4 ^ r3;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x35440;
+                    continue;
+                case 0x3542c:
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = f12;
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = f13;
+                    writePages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff] = r0;
+                    writePages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff] = r0;
+                    r2 = r0 + r0;
+                case 0x35440:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r18 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r17 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r16 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3545c:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff] = f0;
+                    writePages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff] = f1;
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = f0;
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x35440;
+                    continue;
+                case 0x35478:
+                    f4 = readPages[(r28+-31500)>>>12][((r28+-31500)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-31492)>>>12][((r28+-31492)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31504)>>>12][((r28+-31504)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31496)>>>12][((r28+-31496)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x3528c;
+                    run_35200(); return;
+                case 0x35494:
+                    /* Next insn is delay slot */ 
+                    r31=0x3549c;
+                    pc=0x32a00;
+                    run_32a00(); return;
+                case 0x3549c:
+                    f2 = readPages[(r28+-31484)>>>12][((r28+-31484)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-31476)>>>12][((r28+-31476)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31488)>>>12][((r28+-31488)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31480)>>>12][((r28+-31480)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f4 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f4 = (int)(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL))); break; // Round towards zero
+                        case 2: f4 = (int)Math.ceil((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f4 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    { long l = Double.doubleToLongBits(((double)f4)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r2 = f4;
+                    f4 = readPages[(r28+-31516)>>>12][((r28+-31516)>>>2)&0x3ff];
+                    r3 = r2 < 32 ? 1 : 0;
+                    f5 = readPages[(r28+-31520)>>>12][((r28+-31520)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f4 = readPages[(r28+-31508)>>>12][((r28+-31508)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31512)>>>12][((r28+-31512)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x355a8;
+                        continue;
+                    }
+                    r4 = r2 + -1;
+                    r3 = 7 << 16;
+                    r4 = r4 << 2;
+                    r3 = r3 + -280;
+                    r3 = r4 + r3;
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r3 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x355a8;
+                        continue;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    r5 = f6;
+                    r4 = f7;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r5;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r4;
+                case 0x35550:
+                    f6 = r5;
+                    f7 = r4;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r7 = f2;
+                    r6 = f3;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r7;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r6;
+                    if(r17 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35440;
+                        continue;
+                    }
+                    r3 = 32768 << 16;
+                    r4 = r4 ^ r3;
+                    r3 = r6 ^ r3;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r4;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r5;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r3;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r7;
+                    r2 = r0 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x35440;
+                    continue;
+                case 0x355a8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    r18 = r18 >> 20;
+                    r4 = f7;
+                    r5 = f6;
+                    r3 = r4 >>> 20;
+                    r3 = r3 & 2047;
+                    r3 = r18 - r3;
+                    r3 = r3 < 17 ? 1 : 0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r5;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r4;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35550;
+                        continue;
+                    }
+                    f4 = readPages[(r28+-31500)>>>12][((r28+-31500)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31504)>>>12][((r28+-31504)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f0 = readPages[(r28+-31492)>>>12][((r28+-31492)>>>2)&0x3ff];
+                case 0x35600:
+                    pc=0x35600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_35600() throws ExecutionException { /* 0x35600 - 0x35800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x35600:
+                    f1 = readPages[(r28+-31496)>>>12][((r28+-31496)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r4 = f1;
+                    r5 = f0;
+                    r6 = r4 >>> 20;
+                    r6 = r6 & 2047;
+                    r18 = r18 - r6;
+                    r18 = r18 < 50 ? 1 : 0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r5;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r4;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35710;
+                        continue;
+                    }
+                    f4 = readPages[(r28+-31468)>>>12][((r28+-31468)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31472)>>>12][((r28+-31472)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f6 = readPages[(r28+-31460)>>>12][((r28+-31460)>>>2)&0x3ff];
+                    f7 = readPages[(r28+-31464)>>>12][((r28+-31464)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r5 = f2;
+                    r4 = f3;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r5;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x35550;
+                    run_35400(); return;
+                case 0x35690:
+                    r2 = 16377 << 16;
+                    r2 = r2 + 8699;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x356f4;
+                        continue;
+                    }
+                    f2 = readPages[(r28+-31508)>>>12][((r28+-31508)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31512)>>>12][((r28+-31512)>>>2)&0x3ff];
+                case 0x356b4:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r2 = r0 + -1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = f4;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = f5;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = f2;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = f3;
+                    /* Next insn is delay slot */ 
+                    pc=0x35440;
+                    run_35400(); return;
+                case 0x356dc:
+                    r7 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x353d8;
+                    run_35200(); return;
+                case 0x356e8:
+                    r7 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x353d8;
+                    run_35200(); return;
+                case 0x356f4:
+                    f4 = readPages[(r28+-31500)>>>12][((r28+-31500)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-31492)>>>12][((r28+-31492)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31504)>>>12][((r28+-31504)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31496)>>>12][((r28+-31496)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x356b4;
+                    continue;
+                case 0x35710:
+                    f0 = f6;
+                    f1 = f7;
+                    /* Next insn is delay slot */ 
+                    pc=0x35550;
+                    run_35400(); return;
+                case 0x35800:
+                    pc=0x35800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_35800() throws ExecutionException { /* 0x35800 - 0x35a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x35800:
+                    r2 = f13;
+                    r3 = f12;
+                    r6 = 32752 << 16;
+                    r7 = r6 & r2;
+                    r4 = r2 + r0;
+                    r5 = r3 + r0;
+                    if(r7 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35a88;
+                        run_35a00(); return;
+                    }
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x359dc;
+                        continue;
+                    }
+                    r2 = r2 >> 20;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35a14;
+                        run_35a00(); return;
+                    }
+                    r3 = 15 << 16;
+                    r3 = r3 | 65535;
+                    r4 = r4 & r3;
+                    r2 = r2 + -1023;
+                    r3 = 16 << 16;
+                    r4 = r4 | r3;
+                    r3 = r2 & 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x359c4;
+                        continue;
+                    }
+                case 0x35858:
+                    r4 = r4 << 1;
+                    r14 = r2 >> 1;
+                    r2 = r5 >>> 31;
+                    r2 = r4 + r2;
+                    r3 = r5 << 1;
+                    r6 = r0 + 22;
+                    r9 = r0 + r0;
+                    r5 = r0 + r0;
+                    r4 = 32 << 16;
+                case 0x3587c:
+                    r7 = r5 + r4;
+                    r8 = r2 < r7 ? 1 : 0;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35898;
+                        continue;
+                    }
+                    r5 = r7 + r4;
+                    r2 = r2 - r7;
+                    r9 = r9 + r4;
+                case 0x35898:
+                    r7 = r3 >>> 31;
+                    r2 = r2 << 1;
+                    r6 = r6 + -1;
+                    r2 = r2 + r7;
+                    r3 = r3 << 1;
+                    r4 = r4 >>> 1;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3587c;
+                        continue;
+                    }
+                    r7 = r0 + 32;
+                    r11 = r0 + r0;
+                    r10 = r0 + r0;
+                    r4 = 32768 << 16;
+                    r12 = 32768 << 16;
+                case 0x358cc:
+                    r8 = r5 < r2 ? 1 : 0;
+                    r6 = r4 + r10;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x359a4;
+                        continue;
+                    }
+                    r8 = ((r3 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                case 0x358e0:
+                    r13 = r6 & r12;
+                    r10 = r6 + r4;
+                    if(r13 == r12) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3598c;
+                        continue;
+                    }
+                case 0x358f0:
+                    r13 = r5 + r0;
+                case 0x358f4:
+                    r2 = r2 - r5;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35904;
+                        continue;
+                    }
+                    r2 = r2 + -1;
+                case 0x35904:
+                    r3 = r3 - r6;
+                    r11 = r11 + r4;
+                    r5 = r13 + r0;
+                case 0x35910:
+                    r6 = r3 >>> 31;
+                    r2 = r2 << 1;
+                    r7 = r7 + -1;
+                    r2 = r2 + r6;
+                    r3 = r3 << 1;
+                    r4 = r4 >>> 1;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x358cc;
+                        continue;
+                    }
+                    r2 = r2 | r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35950;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                    if(r11 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35aa4;
+                        run_35a00(); return;
+                    }
+                    r2 = r11 & 1;
+                    r11 = r2 + r11;
+                case 0x35950:
+                    r11 = r11 >>> 1;
+                case 0x35954:
+                    r4 = r9 >> 1;
+                    r2 = 16352 << 16;
+                    r9 = r9 & 1;
+                    r4 = r4 + r2;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35974;
+                        continue;
+                    }
+                    r2 = 32768 << 16;
+                    r11 = r11 | r2;
+                case 0x35974:
+                    r14 = r14 << 20;
+                    f0 = r11;
+                    r2 = r14 + r4;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3598c:
+                    r13 = r10 & r12;
+                    if(r13 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x358f0;
+                        continue;
+                    }
+                    r13 = r5 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x358f4;
+                    continue;
+                case 0x359a4:
+                    if(r2 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35910;
+                        continue;
+                    }
+                    r8 = ((r3 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x358e0;
+                        continue;
+                    }
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x35910;
+                    continue;
+                case 0x359c4:
+                    r3 = r5 >>> 31;
+                    r4 = r4 << 1;
+                    r4 = r4 + r3;
+                    r5 = r5 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x35858;
+                    continue;
+                case 0x359dc:
+                    r6 = 32767 << 16;
+                    r6 = r6 | 65535;
+                    r2 = r6 & r2;
+                    r2 = r2 | r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35a98;
+                        run_35a00(); return;
+                    }
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35ac8;
+                        run_35a00(); return;
+                    }
+                    r2 = r0 + r0;
+                case 0x35a00:
+                    pc=0x35a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_35a00() throws ExecutionException { /* 0x35a00 - 0x35c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x35a00:
+                    r4 = r5 >>> 11;
+                    r2 = r2 + -21;
+                    r5 = r5 << 21;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35a00;
+                        continue;
+                    }
+                case 0x35a14:
+                    r3 = 16 << 16;
+                    r3 = r4 & r3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35ab4;
+                        continue;
+                    }
+                    r7 = 16 << 16;
+                case 0x35a28:
+                    r4 = r4 << 1;
+                    r6 = r4 & r7;
+                    r3 = r3 + 1;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35a28;
+                        continue;
+                    }
+                    r7 = r0 + 1;
+                    r6 = r0 + 32;
+                    r7 = r7 - r3;
+                    r6 = r6 - r3;
+                case 0x35a4c:
+                    r6 = r5 >>> (r6&0x1f);
+                    r5 = r5 << (r3&0x1f);
+                    r3 = 15 << 16;
+                    r3 = r3 | 65535;
+                    r2 = r2 + r7;
+                    r4 = r4 | r6;
+                    r4 = r4 & r3;
+                    r2 = r2 + -1023;
+                    r3 = 16 << 16;
+                    r4 = r4 | r3;
+                    r3 = r2 & 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35858;
+                        run_35800(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x359c4;
+                    run_35800(); return;
+                case 0x35a88:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x35a98:
+                    f0 = f12;
+                    f1 = f13;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x35aa4:
+                    r9 = r9 + 1;
+                    r11 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x35954;
+                    run_35800(); return;
+                case 0x35ab4:
+                    r6 = r0 + 32;
+                    r7 = r0 + 1;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x35a4c;
+                    continue;
+                case 0x35ac8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))/(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x35c00:
+                    pc=0x35c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_35c00() throws ExecutionException { /* 0x35c00 - 0x35e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x35c00:
+                    r2 = f13;
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r2 = r3 & r2;
+                    r3 = 15936 << 16;
+                    r3 = r2 < r3 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35d00;
+                        continue;
+                    }
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    r2 = f0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35e20;
+                        run_35e00(); return;
+                    }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31420)>>>12][((r28+-31420)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-31412)>>>12][((r28+-31412)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31424)>>>12][((r28+-31424)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31416)>>>12][((r28+-31416)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31404)>>>12][((r28+-31404)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31408)>>>12][((r28+-31408)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31396)>>>12][((r28+-31396)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31400)>>>12][((r28+-31400)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31388)>>>12][((r28+-31388)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31392)>>>12][((r28+-31392)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31380)>>>12][((r28+-31380)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31384)>>>12][((r28+-31384)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                case 0x35cc8:
+                    f4 = readPages[(r28+-31372)>>>12][((r28+-31372)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f5 = readPages[(r28+-31376)>>>12][((r28+-31376)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f12 = readPages[(r28+-31428)>>>12][((r28+-31428)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f13 = readPages[(r28+-31432)>>>12][((r28+-31432)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x35d00:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31420)>>>12][((r28+-31420)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-31412)>>>12][((r28+-31412)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31424)>>>12][((r28+-31424)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31416)>>>12][((r28+-31416)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = 16339 << 16;
+                    r3 = r3 + 13107;
+                    r3 = r2 < r3 ? 1 : 0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31404)>>>12][((r28+-31404)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31408)>>>12][((r28+-31408)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31396)>>>12][((r28+-31396)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31400)>>>12][((r28+-31400)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31388)>>>12][((r28+-31388)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31392)>>>12][((r28+-31392)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = readPages[(r28+-31380)>>>12][((r28+-31380)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = readPages[(r28+-31384)>>>12][((r28+-31384)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35cc8;
+                        continue;
+                    }
+                    r3 = 16361 << 16;
+                    r3 = r3 + 1;
+                    r3 = r2 < r3 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x35de4;
+                        continue;
+                    }
+                    f6 = readPages[(r28+-31372)>>>12][((r28+-31372)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f7 = readPages[(r28+-31376)>>>12][((r28+-31376)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    r3 = 65504 << 16;
+                    f4 = r5;
+                    f8 = readPages[(r28+-31428)>>>12][((r28+-31428)>>>2)&0x3ff];
+                    r4 = r2 + r3;
+                    f5 = r4;
+                    f9 = readPages[(r28+-31432)>>>12][((r28+-31432)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f15 = (int)(l >>> 32); f14 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x35de4:
+                    f6 = readPages[(r28+-31372)>>>12][((r28+-31372)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f7 = readPages[(r28+-31376)>>>12][((r28+-31376)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f4 = readPages[(r28+-31436)>>>12][((r28+-31436)>>>2)&0x3ff];
+                    f8 = readPages[(r28+-31444)>>>12][((r28+-31444)>>>2)&0x3ff];
+                case 0x35e00:
+                    pc=0x35e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_35e00() throws ExecutionException { /* 0x35e00 - 0x36000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x35e00:
+                    f5 = readPages[(r28+-31440)>>>12][((r28+-31440)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f15 = (int)(l >>> 32); f14 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f9 = readPages[(r28+-31448)>>>12][((r28+-31448)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x35e20:
+                    f0 = readPages[(r28+-31428)>>>12][((r28+-31428)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31432)>>>12][((r28+-31432)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x36000:
+                    pc=0x36000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_36000() throws ExecutionException { /* 0x36000 - 0x36200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x36000:
+                    r29 = r29 + -688;
+                    r2 = readPages[(r29+704)>>>12][((r29+704)>>>2)&0x3ff];
+                    r9 = r6 + -3;
+                    r3 = r2 << 2;
+                    r2 = 7 << 16;
+                    r2 = r2 + 176;
+                    r2 = r3 + r2;
+                    writePages[(r29+608)>>>12][((r29+608)>>>2)&0x3ff] = r18;
+                    r18 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 24;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        hi = r9%r2; lo = r9/r2;
+                        pc=0x36034;
+                        continue;
+                    }
+                    hi = r9%r2; lo = r9/r2;
+                    throw new ExecutionException("Break");
+                case 0x36034:
+                    writePages[(r29+628)>>>12][((r29+628)>>>2)&0x3ff] = r23;
+                    writePages[(r29+612)>>>12][((r29+612)>>>2)&0x3ff] = r19;
+                    writePages[(r29+604)>>>12][((r29+604)>>>2)&0x3ff] = r17;
+                    writePages[(r29+636)>>>12][((r29+636)>>>2)&0x3ff] = r31;
+                    writePages[(r29+632)>>>12][((r29+632)>>>2)&0x3ff] = r30;
+                    writePages[(r29+624)>>>12][((r29+624)>>>2)&0x3ff] = r22;
+                    writePages[(r29+620)>>>12][((r29+620)>>>2)&0x3ff] = r21;
+                    writePages[(r29+616)>>>12][((r29+616)>>>2)&0x3ff] = r20;
+                    writePages[(r29+600)>>>12][((r29+600)>>>2)&0x3ff] = r16;
+                    writePages[(r29+684)>>>12][((r29+684)>>>2)&0x3ff] = f30;
+                    writePages[(r29+680)>>>12][((r29+680)>>>2)&0x3ff] = f31;
+                    writePages[(r29+676)>>>12][((r29+676)>>>2)&0x3ff] = f28;
+                    writePages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff] = f29;
+                    writePages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff] = f26;
+                    writePages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff] = f27;
+                    writePages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff] = f24;
+                    writePages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff] = f25;
+                    writePages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff] = f22;
+                    writePages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff] = f23;
+                    writePages[(r29+644)>>>12][((r29+644)>>>2)&0x3ff] = f20;
+                    writePages[(r29+640)>>>12][((r29+640)>>>2)&0x3ff] = f21;
+                    r17 = r4 + r0;
+                    r23 = r5 + r0;
+                    r19 = r7 + -1;
+                    r9 = lo;
+                    if(r9 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36c60;
+                        run_36c00(); return;
+                    }
+                case 0x360a0:
+                    r2 = ~(r0 | r9);
+                    r3 = r2 << 3;
+                    r2 = r2 << 5;
+                    r30 = r2 - r3;
+                    r5 = r19 + r18;
+                    r30 = r30 + r6;
+                    r2 = r9 - r19;
+                    if(r5 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3610c;
+                        continue;
+                    }
+                    r6 = readPages[(r29+708)>>>12][((r29+708)>>>2)&0x3ff];
+                    r4 = r2 << 2;
+                    r5 = r2 + r5;
+                    r3 = r29 + 336;
+                    r4 = r6 + r4;
+                    r5 = r5 + 1;
+                case 0x360dc:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x368a8;
+                        run_36800(); return;
+                    }
+                    f2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x360f0:
+                    r2 = r2 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = f0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = f1;
+                    r4 = r4 + 4;
+                    r3 = r3 + 8;
+                    if(r2 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x360dc;
+                        continue;
+                    }
+                case 0x3610c:
+                    if(r18 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36d44;
+                        run_36c00(); return;
+                    }
+                    r16 = r7 << 3;
+                    r8 = r18 + 1;
+                    r6 = r29 + r16;
+                    r8 = r8 << 3;
+                    r5 = r0 + r0;
+                    r21 = r29 + 16;
+                    r6 = r6 + 328;
+                case 0x36130:
+                    if(r19 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36938;
+                        run_36800(); return;
+                    }
+                    f0 = r0;
+                    r3 = r6 + r5;
+                    f1 = r0;
+                    r2 = r0 + r0;
+                case 0x36148:
+                    r4 = r17 + r2;
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    f5 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r2 + 8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = r3 + -8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36148;
+                        continue;
+                    }
+                    r2 = r21 + r5;
+                    r5 = r5 + 8;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = f0;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = f1;
+                    if(r5 != r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36130;
+                        continue;
+                    }
+                case 0x3618c:
+                    r2 = r29 + 492;
+                    r20 = r18 << 2;
+                    writePages[(r29+576)>>>12][((r29+576)>>>2)&0x3ff] = r2;
+                    r20 = r2 + r20;
+                    r2 = r18 + -1;
+                    r2 = r2 << 2;
+                    r2 = r21 + r2;
+                    f28 = readPages[(r28+-31348)>>>12][((r28+-31348)>>>2)&0x3ff];
+                    f30 = readPages[(r28+-31340)>>>12][((r28+-31340)>>>2)&0x3ff];
+                    f20 = readPages[(r28+-31324)>>>12][((r28+-31324)>>>2)&0x3ff];
+                    f24 = readPages[(r28+-31364)>>>12][((r28+-31364)>>>2)&0x3ff];
+                    f22 = readPages[(r28+-31356)>>>12][((r28+-31356)>>>2)&0x3ff];
+                    writePages[(r29+584)>>>12][((r29+584)>>>2)&0x3ff] = r2;
+                    r2 = r18 + -2;
+                    r2 = r2 << 2;
+                    f29 = readPages[(r28+-31352)>>>12][((r28+-31352)>>>2)&0x3ff];
+                    f31 = readPages[(r28+-31344)>>>12][((r28+-31344)>>>2)&0x3ff];
+                    f21 = readPages[(r28+-31328)>>>12][((r28+-31328)>>>2)&0x3ff];
+                    f25 = readPages[(r28+-31368)>>>12][((r28+-31368)>>>2)&0x3ff];
+                    f23 = readPages[(r28+-31360)>>>12][((r28+-31360)>>>2)&0x3ff];
+                    r22 = r18 + r0;
+                    r8 = r18 << 3;
+                    writePages[(r29+588)>>>12][((r29+588)>>>2)&0x3ff] = r2;
+                case 0x361e8:
+                    r8 = r21 + r8;
+                    f12 = readPages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff];
+                    f13 = readPages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff];
+                    if(r22 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36298;
+                        run_36200(); return;
+                    }
+                case 0x36200:
+                    pc=0x36200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_36200() throws ExecutionException { /* 0x36200 - 0x36400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x36200:
+                    r2 = r22 + -1;
+                    r2 = r2 << 3;
+                    r3 = r29 + 496;
+                    r2 = r21 + r2;
+                    r4 = r29 + 8;
+                case 0x36214:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f25&0xffffffffL) << 32) | (f24&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r2 = r2 + -8;
+                    r3 = r3 + 4;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    { long l = Double.doubleToLongBits(((double)f0)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    f12 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = f2;
+                    f13 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36214;
+                        continue;
+                    }
+                case 0x36298:
+                    r6 = r30 + r0;
+                    writePages[(r29+592)>>>12][((r29+592)>>>2)&0x3ff] = r9;
+                    /* Next insn is delay slot */ 
+                    r31=0x362a8;
+                    pc=0x38400;
+                    run_38400(); return;
+                case 0x362a8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f29&0xffffffffL) << 32) | (f28&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f26 = f0;
+                    f27 = f1;
+                    /* Next insn is delay slot */ 
+                    r31=0x362b8;
+                    pc=0x37600;
+                    run_37600(); return;
+                case 0x362b8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f31&0xffffffffL) << 32) | (f30&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r9 = readPages[(r29+592)>>>12][((r29+592)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f27 = (int)(l >>> 32); f26 = (int)l; }
+                    r2 = fcsr;
+                    r2 = fcsr;
+                    r1 = r2 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r2;
+                    writePages[(r29+580)>>>12][((r29+580)>>>2)&0x3ff] = f0;
+                    { long l = Double.doubleToLongBits(((double)f0)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f27 = (int)(l >>> 32); f26 = (int)l; }
+                    if(r30 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x368bc;
+                        run_36800(); return;
+                    }
+                    r3 = r22 + -1;
+                    r3 = r3 << 2;
+                    r3 = r21 + r3;
+                    r2 = readPages[(r3+480)>>>12][((r3+480)>>>2)&0x3ff];
+                    r4 = r0 + 24;
+                    r4 = r4 - r30;
+                    r5 = r2 >> (r4&0x1f);
+                    r7 = readPages[(r29+580)>>>12][((r29+580)>>>2)&0x3ff];
+                    r4 = r5 << (r4&0x1f);
+                    r2 = r2 - r4;
+                    r4 = r0 + 23;
+                    r7 = r7 + r5;
+                    r4 = r4 - r30;
+                    writePages[(r29+580)>>>12][((r29+580)>>>2)&0x3ff] = r7;
+                    writePages[(r3+480)>>>12][((r3+480)>>>2)&0x3ff] = r2;
+                    r4 = r2 >> (r4&0x1f);
+                case 0x36340:
+                    if(r4 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36414;
+                        run_36400(); return;
+                    }
+                    r2 = readPages[(r29+580)>>>12][((r29+580)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r29+580)>>>12][((r29+580)>>>2)&0x3ff] = r2;
+                    if(r22 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36978;
+                        run_36800(); return;
+                    }
+                case 0x36360:
+                    r2 = r29 + 496;
+                    r6 = r22 << 2;
+                    r7 = 255 << 16;
+                    r6 = r2 + r6;
+                    r5 = r0 + r0;
+                    r7 = r7 | 65535;
+                    r8 = 256 << 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x363a4;
+                    continue;
+                case 0x36384:
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36398;
+                        continue;
+                    }
+                    r3 = r8 - r3;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r5 = r0 + 1;
+                case 0x36398:
+                    r2 = r2 + 4;
+                    if(r2 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x363c8;
+                        continue;
+                    }
+                case 0x363a4:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36384;
+                        continue;
+                    }
+                    r3 = r7 - r3;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r2 + 4;
+                    r5 = r0 + 1;
+                    if(r2 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x363a4;
+                        continue;
+                    }
+                case 0x363c8:
+                    if(r30 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36408;
+                        run_36400(); return;
+                    }
+                    r2 = r0 + 1;
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x368e4;
+                        run_36800(); return;
+                    }
+                    r2 = r0 + 2;
+                    if(r30 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36408;
+                        run_36400(); return;
+                    }
+                    r2 = r22 + -1;
+                    r2 = r2 << 2;
+                    r2 = r21 + r2;
+                    r6 = readPages[(r2+480)>>>12][((r2+480)>>>2)&0x3ff];
+                    r3 = 63 << 16;
+                    r3 = r3 | 65535;
+                case 0x36400:
+                    pc=0x36400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_36400() throws ExecutionException { /* 0x36400 - 0x36600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x36400:
+                    r3 = r6 & r3;
+                    writePages[(r2+480)>>>12][((r2+480)>>>2)&0x3ff] = r3;
+                case 0x36408:
+                    r2 = r0 + 2;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x365b0;
+                        continue;
+                    }
+                case 0x36414:
+                    f0 = r0;
+                    f1 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x365f8;
+                        continue;
+                    }
+                case 0x36434:
+                    r5 = r22 + -1;
+                    r2 = r5 < r18 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36470;
+                        continue;
+                    }
+                    r3 = r29 + 496;
+                    r7 = r5 << 2;
+                    r2 = r3 + r7;
+                    r3 = r0 + r0;
+                case 0x36454:
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r2 + -4;
+                    r3 = r3 | r6;
+                    if(r2 != r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36454;
+                        continue;
+                    }
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36c10;
+                        run_36c00(); return;
+                    }
+                case 0x36470:
+                    r4 = readPages[(r29+584)>>>12][((r29+584)>>>2)&0x3ff];
+                    r2 = readPages[(r4+480)>>>12][((r4+480)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36c04;
+                        run_36c00(); return;
+                    }
+                    r7 = readPages[(r29+588)>>>12][((r29+588)>>>2)&0x3ff];
+                    r5 = r29 + 496;
+                    r2 = r5 + r7;
+                    r3 = r0 + 1;
+                case 0x36498:
+                    r2 = r2 + -4;
+                    r4 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36498;
+                        continue;
+                    }
+                case 0x364ac:
+                    r2 = r22 + 1;
+                    r22 = r22 + r3;
+                    r3 = r22 < r2 ? 1 : 0;
+                    r8 = r22 << 3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x361e8;
+                        run_36000(); return;
+                    }
+                    r5 = r2 + r9;
+                    r3 = readPages[(r29+708)>>>12][((r29+708)>>>2)&0x3ff];
+                    r5 = r5 << 2;
+                    r5 = r3 + r5;
+                    r7 = r19 + r2;
+                    f2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r4 = r29 + 336;
+                    r2 = r2 << 3;
+                    r7 = r7 << 3;
+                    r7 = r4 + r7;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r4 = r21 + r2;
+                    r8 = r22 << 3;
+                    r2 = r29 + 24;
+                    r6 = r2 + r8;
+                    writePages[(r7+4)>>>12][((r7+4)>>>2)&0x3ff] = f0;
+                    writePages[(r7+0)>>>12][((r7+0)>>>2)&0x3ff] = f1;
+                    if(r19 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36584;
+                        continue;
+                    }
+                case 0x36510:
+                    f0 = r0;
+                    r3 = r7 + r0;
+                    f1 = r0;
+                    r2 = r0 + r0;
+                case 0x36520:
+                    r10 = r17 + r2;
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f4 = readPages[(r10+4)>>>12][((r10+4)>>>2)&0x3ff];
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    f5 = readPages[(r10+0)>>>12][((r10+0)>>>2)&0x3ff];
+                    r2 = r2 + 8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = r3 + -8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36520;
+                        continue;
+                    }
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = f0;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = f1;
+                    r4 = r4 + 8;
+                    r5 = r5 + 4;
+                    r7 = r7 + 8;
+                    if(r4 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x361e8;
+                        run_36000(); return;
+                    }
+                case 0x36568:
+                    f2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r7+4)>>>12][((r7+4)>>>2)&0x3ff] = f0;
+                    writePages[(r7+0)>>>12][((r7+0)>>>2)&0x3ff] = f1;
+                    if(r19 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36510;
+                        continue;
+                    }
+                case 0x36584:
+                    f0 = r0;
+                    r4 = r4 + 8;
+                    f1 = r0;
+                    r5 = r5 + 4;
+                    writePages[(r4+-4)>>>12][((r4+-4)>>>2)&0x3ff] = f0;
+                    writePages[(r4+-8)>>>12][((r4+-8)>>>2)&0x3ff] = f1;
+                    r7 = r7 + 8;
+                    if(r4 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36568;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x361e8;
+                    run_36000(); return;
+                case 0x365b0:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))-(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))); f27 = (int)(l >>> 32); f26 = (int)l; }
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36414;
+                        continue;
+                    }
+                    f12 = f20;
+                    f13 = f21;
+                    r6 = r30 + r0;
+                    writePages[(r29+596)>>>12][((r29+596)>>>2)&0x3ff] = r4;
+                    writePages[(r29+592)>>>12][((r29+592)>>>2)&0x3ff] = r9;
+                    /* Next insn is delay slot */ 
+                    r31=0x365d4;
+                    pc=0x38400;
+                    run_38400(); return;
+                case 0x365d4:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f27 = (int)(l >>> 32); f26 = (int)l; }
+                    f0 = r0;
+                    r9 = readPages[(r29+592)>>>12][((r29+592)>>>2)&0x3ff];
+                    f1 = r0;
+                    r4 = readPages[(r29+596)>>>12][((r29+596)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36434;
+                        continue;
+                    }
+                case 0x365f8:
+                    f12 = f26;
+                    f13 = f27;
+                    r6 = r0 - r30;
+                case 0x36600:
+                    pc=0x36600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_36600() throws ExecutionException { /* 0x36600 - 0x36800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x36600:
+                    writePages[(r29+596)>>>12][((r29+596)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    r31=0x3660c;
+                    pc=0x38400;
+                    run_38400(); return;
+                case 0x3660c:
+                    f2 = readPages[(r28+-31356)>>>12][((r28+-31356)>>>2)&0x3ff];
+                    r4 = readPages[(r29+596)>>>12][((r29+596)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31360)>>>12][((r28+-31360)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<=(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36c6c;
+                        run_36c00(); return;
+                    }
+                    f4 = readPages[(r28+-31364)>>>12][((r28+-31364)>>>2)&0x3ff];
+                    r5 = r22 + 1;
+                    f5 = readPages[(r28+-31368)>>>12][((r28+-31368)>>>2)&0x3ff];
+                    r30 = r30 + 24;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r2 = fcsr;
+                    r2 = fcsr;
+                    r1 = r2 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f4 = (int)Math.floor((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f4 = (int)(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL))); break; // Round towards zero
+                        case 2: f4 = (int)Math.ceil((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f4 = (int)Math.floor((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r2;
+                    { long l = Double.doubleToLongBits(((double)f4)); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r2 = r22 << 2;
+                    r2 = r21 + r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r2+480)>>>12][((r2+480)>>>2)&0x3ff] = f2;
+                    r2 = r5 << 2;
+                    r2 = r21 + r2;
+                    writePages[(r2+480)>>>12][((r2+480)>>>2)&0x3ff] = f4;
+                case 0x366b4:
+                    f12 = f20;
+                    f13 = f21;
+                    r6 = r30 + r0;
+                    writePages[(r29+596)>>>12][((r29+596)>>>2)&0x3ff] = r4;
+                    writePages[(r29+592)>>>12][((r29+592)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x366cc;
+                    pc=0x38400;
+                    run_38400(); return;
+                case 0x366cc:
+                    r5 = readPages[(r29+592)>>>12][((r29+592)>>>2)&0x3ff];
+                    r4 = readPages[(r29+596)>>>12][((r29+596)>>>2)&0x3ff];
+                    if(r5 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x367b4;
+                        continue;
+                    }
+                    f4 = readPages[(r28+-31364)>>>12][((r28+-31364)>>>2)&0x3ff];
+                    r3 = r29 + 496;
+                    r2 = r5 << 2;
+                    r9 = r5 << 3;
+                    f5 = readPages[(r28+-31368)>>>12][((r28+-31368)>>>2)&0x3ff];
+                    r2 = r3 + r2;
+                    r3 = r21 + r9;
+                case 0x366f8:
+                    f6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r7 = readPages[(r29+576)>>>12][((r29+576)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits(((double)f6)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r2 = r2 + -4;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r3 = r3 + -8;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f2;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f3;
+                    if(r2 != r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x366f8;
+                        continue;
+                    }
+                    r9 = r21 + r9;
+                    r11 = r5 + 1;
+                    r8 = r0 + r0;
+                    r10 = 7 << 16;
+                case 0x36734:
+                    if(r18 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36984;
+                        run_36800(); return;
+                    }
+                    f0 = r0;
+                    r6 = r10 + 112;
+                    r3 = r9 + r0;
+                    f1 = r0;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3676c;
+                    continue;
+                case 0x36758:
+                    r7 = r8 < r2 ? 1 : 0;
+                    r6 = r6 + 8;
+                    r3 = r3 + 8;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36794;
+                        continue;
+                    }
+                case 0x3676c:
+                    f4 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f5 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r7 = r18 < r2 ? 1 : 0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36758;
+                        continue;
+                    }
+                case 0x36794:
+                    r2 = r8 << 3;
+                    r2 = r21 + r2;
+                    r8 = r8 + 1;
+                    writePages[(r2+164)>>>12][((r2+164)>>>2)&0x3ff] = f0;
+                    writePages[(r2+160)>>>12][((r2+160)>>>2)&0x3ff] = f1;
+                    r9 = r9 + -8;
+                    if(r8 != r11) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36734;
+                        continue;
+                    }
+                case 0x367b4:
+                    r3 = readPages[(r29+704)>>>12][((r29+704)>>>2)&0x3ff];
+                    r2 = r3 < 3 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36a94;
+                        run_36a00(); return;
+                    }
+                    if(r3 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x369b4;
+                        run_36800(); return;
+                    }
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3683c;
+                        run_36800(); return;
+                    }
+                    if(r5 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36d34;
+                        run_36c00(); return;
+                    }
+                    r2 = r29 + 176;
+                    r5 = r5 << 3;
+                    r5 = r2 + r5;
+                    r6 = r29 + 168;
+                    r3 = r0 + r0;
+                    r2 = r0 + r0;
+                case 0x367f8:
+                    f0 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    f2 = r3;
+                case 0x36800:
+                    pc=0x36800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_36800() throws ExecutionException { /* 0x36800 - 0x36a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x36800:
+                    f1 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    f3 = r2;
+                    r5 = r5 + -8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = f2;
+                    r2 = f3;
+                    if(r5 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x367f8;
+                        run_36600(); return;
+                    }
+                case 0x36820:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36d1c;
+                        run_36c00(); return;
+                    }
+                    r6 = 32768 << 16;
+                    r4 = r2 ^ r6;
+                    r5 = r3 + r0;
+                    writePages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff] = r5;
+                    writePages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff] = r4;
+                case 0x3683c:
+                    r3 = readPages[(r29+580)>>>12][((r29+580)>>>2)&0x3ff];
+                    f30 = readPages[(r29+684)>>>12][((r29+684)>>>2)&0x3ff];
+                    f28 = readPages[(r29+676)>>>12][((r29+676)>>>2)&0x3ff];
+                    f26 = readPages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff];
+                    f24 = readPages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff];
+                    f22 = readPages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff];
+                    f20 = readPages[(r29+644)>>>12][((r29+644)>>>2)&0x3ff];
+                    r31 = readPages[(r29+636)>>>12][((r29+636)>>>2)&0x3ff];
+                    r30 = readPages[(r29+632)>>>12][((r29+632)>>>2)&0x3ff];
+                    r23 = readPages[(r29+628)>>>12][((r29+628)>>>2)&0x3ff];
+                    r22 = readPages[(r29+624)>>>12][((r29+624)>>>2)&0x3ff];
+                    r21 = readPages[(r29+620)>>>12][((r29+620)>>>2)&0x3ff];
+                    r20 = readPages[(r29+616)>>>12][((r29+616)>>>2)&0x3ff];
+                    r19 = readPages[(r29+612)>>>12][((r29+612)>>>2)&0x3ff];
+                    r18 = readPages[(r29+608)>>>12][((r29+608)>>>2)&0x3ff];
+                    r17 = readPages[(r29+604)>>>12][((r29+604)>>>2)&0x3ff];
+                    r16 = readPages[(r29+600)>>>12][((r29+600)>>>2)&0x3ff];
+                    f31 = readPages[(r29+680)>>>12][((r29+680)>>>2)&0x3ff];
+                    f29 = readPages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff];
+                    f27 = readPages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff];
+                    f25 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    f23 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    f21 = readPages[(r29+640)>>>12][((r29+640)>>>2)&0x3ff];
+                    r2 = r3 & 7;
+                    r29 = r29 + 688;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x368a8:
+                    f0 = r0;
+                    f1 = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x360f0;
+                    run_36000(); return;
+                case 0x368bc:
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3690c;
+                        continue;
+                    }
+                    r2 = r22 + -1;
+                    r2 = r2 << 2;
+                    r2 = r21 + r2;
+                    r4 = readPages[(r2+480)>>>12][((r2+480)>>>2)&0x3ff];
+                    r4 = r4 >> 23;
+                    /* Next insn is delay slot */ 
+                    pc=0x36340;
+                    run_36200(); return;
+                case 0x368e4:
+                    r2 = r22 + -1;
+                    r2 = r2 << 2;
+                    r2 = r21 + r2;
+                    r6 = readPages[(r2+480)>>>12][((r2+480)>>>2)&0x3ff];
+                    r3 = 127 << 16;
+                    r3 = r3 | 65535;
+                    r3 = r6 & r3;
+                    writePages[(r2+480)>>>12][((r2+480)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x36408;
+                    run_36400(); return;
+                case 0x3690c:
+                    f2 = readPages[(r28+-31332)>>>12][((r28+-31332)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31336)>>>12][((r28+-31336)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<=(Double.longBitsToDouble(((f27&0xffffffffL) << 32) | (f26&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36960;
+                        continue;
+                    }
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x36414;
+                    run_36400(); return;
+                case 0x36938:
+                    f0 = r0;
+                    r2 = r21 + r5;
+                    f1 = r0;
+                    r5 = r5 + 8;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = f0;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = f1;
+                    if(r5 != r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36130;
+                        run_36000(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3618c;
+                    run_36000(); return;
+                case 0x36960:
+                    r2 = readPages[(r29+580)>>>12][((r29+580)>>>2)&0x3ff];
+                    r4 = r0 + 2;
+                    r2 = r2 + 1;
+                    writePages[(r29+580)>>>12][((r29+580)>>>2)&0x3ff] = r2;
+                    if(r22 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36360;
+                        run_36200(); return;
+                    }
+                case 0x36978:
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x363c8;
+                    run_36200(); return;
+                case 0x36984:
+                    f0 = r0;
+                    r2 = r8 << 3;
+                    f1 = r0;
+                    r2 = r21 + r2;
+                    r8 = r8 + 1;
+                    writePages[(r2+164)>>>12][((r2+164)>>>2)&0x3ff] = f0;
+                    writePages[(r2+160)>>>12][((r2+160)>>>2)&0x3ff] = f1;
+                    r9 = r9 + -8;
+                    if(r8 != r11) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36734;
+                        run_36600(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x367b4;
+                    run_36600(); return;
+                case 0x369b4:
+                    if(r5 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36d0c;
+                        run_36c00(); return;
+                    }
+                    r2 = r29 + 176;
+                    r6 = r5 << 3;
+                    r6 = r2 + r6;
+                    r7 = r29 + 168;
+                    r3 = r0 + r0;
+                    r2 = r0 + r0;
+                case 0x369d4:
+                    f0 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    f2 = r3;
+                    f1 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    f3 = r2;
+                    r6 = r6 + -8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = f2;
+                    r2 = f3;
+                    if(r6 != r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x369d4;
+                        continue;
+                    }
+                case 0x369fc:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36bf4;
+                        run_36a00(); return;
+                    }
+                case 0x36a00:
+                    pc=0x36a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_36a00() throws ExecutionException { /* 0x36a00 - 0x36c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x36a00:
+                    r8 = 32768 << 16;
+                    r6 = r2 ^ r8;
+                    r7 = r3 + r0;
+                case 0x36a10:
+                    f2 = r3;
+                    f0 = readPages[(r29+180)>>>12][((r29+180)>>>2)&0x3ff];
+                    f3 = r2;
+                    f1 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    writePages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff] = r7;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff] = r6;
+                    r3 = f2;
+                    r2 = f3;
+                    if(r5 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36a70;
+                        continue;
+                    }
+                    r6 = r29 + 184;
+                    r5 = r5 << 3;
+                    r5 = r6 + r5;
+                case 0x36a48:
+                    f0 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    f2 = r3;
+                    f1 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    f3 = r2;
+                    r6 = r6 + 8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = f2;
+                    r2 = f3;
+                    if(r6 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36a48;
+                        continue;
+                    }
+                case 0x36a70:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36cac;
+                        run_36c00(); return;
+                    }
+                    r6 = 32768 << 16;
+                    r4 = r2 ^ r6;
+                    r5 = r3 + r0;
+                    writePages[(r23+12)>>>12][((r23+12)>>>2)&0x3ff] = r5;
+                    writePages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x3683c;
+                    run_36800(); return;
+                case 0x36a94:
+                    r7 = readPages[(r29+704)>>>12][((r29+704)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    if(r7 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3683c;
+                        run_36800(); return;
+                    }
+                    if(r5 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36cfc;
+                        run_36c00(); return;
+                    }
+                    r9 = r5 << 3;
+                    r2 = r21 + r9;
+                    f0 = readPages[(r2+164)>>>12][((r2+164)>>>2)&0x3ff];
+                    r6 = r29 + 176;
+                    f1 = readPages[(r2+160)>>>12][((r2+160)>>>2)&0x3ff];
+                    r2 = r5 + -1;
+                    r2 = r2 << 3;
+                    r2 = r6 + r2;
+                    r7 = r29 + 168;
+                    r3 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x36ae0;
+                    continue;
+                case 0x36adc:
+                    f0 = f2;
+                    f1 = f3;
+                case 0x36ae0:
+                    f4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r3 + -8;
+                    f5 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = f2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = f3;
+                    writePages[(r3+20)>>>12][((r3+20)>>>2)&0x3ff] = f0;
+                    writePages[(r3+16)>>>12][((r3+16)>>>2)&0x3ff] = f1;
+                    if(r3 != r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36adc;
+                        continue;
+                    }
+                    r5 = r5 < 2 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36cfc;
+                        run_36c00(); return;
+                    }
+                    r21 = r21 + r9;
+                    f0 = readPages[(r21+164)>>>12][((r21+164)>>>2)&0x3ff];
+                    f1 = readPages[(r21+160)>>>12][((r21+160)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x36b3c;
+                    continue;
+                case 0x36b38:
+                    f0 = f2;
+                    f1 = f3;
+                case 0x36b3c:
+                    f4 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 + -8;
+                    f5 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = f2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = f3;
+                    writePages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff] = f0;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = f1;
+                    if(r6 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36b38;
+                        continue;
+                    }
+                    r9 = r6 + r9;
+                    r3 = r0 + r0;
+                    r6 = r6 + 8;
+                    r2 = r0 + r0;
+                case 0x36b80:
+                    f0 = readPages[(r9+4)>>>12][((r9+4)>>>2)&0x3ff];
+                    f2 = r3;
+                    f1 = readPages[(r9+0)>>>12][((r9+0)>>>2)&0x3ff];
+                    f3 = r2;
+                    r9 = r9 + -8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = f2;
+                    r2 = f3;
+                    if(r9 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36b80;
+                        continue;
+                    }
+                case 0x36ba8:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36cc4;
+                        run_36c00(); return;
+                    }
+                    r5 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r4 = 32768 << 16;
+                    r5 = r5 ^ r4;
+                    writePages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff] = r5;
+                    r5 = readPages[(r29+180)>>>12][((r29+180)>>>2)&0x3ff];
+                    writePages[(r23+20)>>>12][((r23+20)>>>2)&0x3ff] = r3;
+                    writePages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff] = r5;
+                    r5 = readPages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff];
+                    r5 = r5 ^ r4;
+                    writePages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff] = r5;
+                    r5 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    r4 = r2 ^ r4;
+                    writePages[(r23+12)>>>12][((r23+12)>>>2)&0x3ff] = r5;
+                    writePages[(r23+16)>>>12][((r23+16)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x3683c;
+                    run_36800(); return;
+                case 0x36bf4:
+                    r7 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x36a10;
+                    continue;
+                case 0x36c00:
+                    pc=0x36c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_36c00() throws ExecutionException { /* 0x36c00 - 0x36e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x36c00:
+                case 0x36c04:
+                    r3 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x364ac;
+                    run_36400(); return;
+                case 0x36c10:
+                    r7 = r21 + r7;
+                    r2 = readPages[(r7+480)>>>12][((r7+480)>>>2)&0x3ff];
+                    r30 = r30 + -24;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x366b4;
+                        run_36600(); return;
+                    }
+                    r3 = r5 + -1;
+                    r2 = r3 << 2;
+                    r5 = r29 + 496;
+                    r2 = r5 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x36c40;
+                    continue;
+                case 0x36c3c:
+                    r3 = r3 + -1;
+                case 0x36c40:
+                    r2 = r2 + -4;
+                    r6 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = r3 + r0;
+                    r30 = r30 + -24;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36c3c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x366b4;
+                    run_36600(); return;
+                case 0x36c60:
+                    r9 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x360a0;
+                    run_36000(); return;
+                case 0x36c6c:
+                    r2 = r22 << 2;
+                    r2 = r21 + r2;
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    writePages[(r2+480)>>>12][((r2+480)>>>2)&0x3ff] = f2;
+                    r5 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x366b4;
+                    run_36600(); return;
+                case 0x36cac:
+                    r5 = r3 + r0;
+                    r4 = r2 + r0;
+                    writePages[(r23+12)>>>12][((r23+12)>>>2)&0x3ff] = r5;
+                    writePages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x3683c;
+                    run_36800(); return;
+                case 0x36cc4:
+                    f0 = readPages[(r29+180)>>>12][((r29+180)>>>2)&0x3ff];
+                    writePages[(r23+20)>>>12][((r23+20)>>>2)&0x3ff] = r3;
+                    f1 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    writePages[(r23+16)>>>12][((r23+16)>>>2)&0x3ff] = r2;
+                    writePages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff] = f0;
+                    writePages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff] = f1;
+                    f0 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    f1 = readPages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff];
+                    writePages[(r23+12)>>>12][((r23+12)>>>2)&0x3ff] = f0;
+                    writePages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3683c;
+                    run_36800(); return;
+                case 0x36cfc:
+                    r3 = r0 + r0;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x36ba8;
+                    run_36a00(); return;
+                case 0x36d0c:
+                    r3 = r0 + r0;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x369fc;
+                    run_36800(); return;
+                case 0x36d1c:
+                    r5 = r3 + r0;
+                    r4 = r2 + r0;
+                    writePages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff] = r5;
+                    writePages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x3683c;
+                    run_36800(); return;
+                case 0x36d34:
+                    r3 = r0 + r0;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x36820;
+                    run_36800(); return;
+                case 0x36d44:
+                    r16 = r7 << 3;
+                    r21 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x3618c;
+                    run_36000(); return;
+                case 0x36e00:
+                    pc=0x36e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_36e00() throws ExecutionException { /* 0x36e00 - 0x37000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x36e00:
+                    r2 = f13;
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r2 = r3 & r2;
+                    r3 = 15936 << 16;
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36e58;
+                        continue;
+                    }
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    r2 = f0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36f28;
+                        continue;
+                    }
+                case 0x36e58:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f6 = readPages[(r28+-31316)>>>12][((r28+-31316)>>>2)&0x3ff];
+                    f8 = readPages[(r28+-31308)>>>12][((r28+-31308)>>>2)&0x3ff];
+                    f7 = readPages[(r28+-31320)>>>12][((r28+-31320)>>>2)&0x3ff];
+                    f9 = readPages[(r28+-31312)>>>12][((r28+-31312)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f4 = readPages[(r28+-31284)>>>12][((r28+-31284)>>>2)&0x3ff];
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31288)>>>12][((r28+-31288)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-31300)>>>12][((r28+-31300)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-31304)>>>12][((r28+-31304)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f8 = readPages[(r28+-31292)>>>12][((r28+-31292)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f9 = readPages[(r28+-31296)>>>12][((r28+-31296)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x36f00;
+                        continue;
+                    }
+                    f6 = readPages[(r28+-31268)>>>12][((r28+-31268)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f7 = readPages[(r28+-31272)>>>12][((r28+-31272)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))); f15 = (int)(l >>> 32); f14 = (int)l; }
+                    f2 = readPages[(r28+-31276)>>>12][((r28+-31276)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31280)>>>12][((r28+-31280)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x36f00:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f8 = readPages[(r28+-31276)>>>12][((r28+-31276)>>>2)&0x3ff];
+                    f9 = readPages[(r28+-31280)>>>12][((r28+-31280)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x36f28:
+                    f0 = f12;
+                    f1 = f13;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37000:
+                    pc=0x37000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_37000() throws ExecutionException { /* 0x37000 - 0x37200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x37000:
+                    r2 = f13;
+                    r10 = 32767 << 16;
+                    r10 = r10 | 65535;
+                    r10 = r10 & r2;
+                    r8 = 15920 << 16;
+                    r29 = r29 + -24;
+                    r8 = r10 < r8 ? 1 : 0;
+                    r3 = f12;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r5 = f14;
+                    r4 = f15;
+                    r6 = r2 + r0;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x370cc;
+                        continue;
+                    }
+                    f12 = r3;
+                    f13 = r2;
+                    r12 = fcsr;
+                    r12 = fcsr;
+                    r1 = r12 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r12;
+                    r8 = f0;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37124;
+                        continue;
+                    }
+                    r5 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r10 = r10 | r3;
+                    r4 = r5 + 1;
+                    r10 = r10 | r4;
+                    if(r10 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37368;
+                        run_37200(); return;
+                    }
+                    r6 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    if(r6 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x373b4;
+                        run_37200(); return;
+                    }
+                    f0 = readPages[(r28+-31252)>>>12][((r28+-31252)>>>2)&0x3ff];
+                    f2 = r3;
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31256)>>>12][((r28+-31256)>>>2)&0x3ff];
+                    f3 = r2;
+                    r29 = r29 + 24;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x370cc:
+                    r8 = 16357 << 16;
+                    r8 = r8 | 37928;
+                    r8 = r10 < r8 ? 1 : 0;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37124;
+                        continue;
+                    }
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3738c;
+                        run_37200(); return;
+                    }
+                case 0x370e8:
+                    f4 = r3;
+                    f0 = readPages[(r28+-31244)>>>12][((r28+-31244)>>>2)&0x3ff];
+                    f5 = r2;
+                    f1 = readPages[(r28+-31248)>>>12][((r28+-31248)>>>2)&0x3ff];
+                    f10 = r5;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f0 = readPages[(r28+-31236)>>>12][((r28+-31236)>>>2)&0x3ff];
+                    f11 = r4;
+                    f1 = readPages[(r28+-31240)>>>12][((r28+-31240)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r4 = r0 + r0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r3 = f4;
+                    r2 = f5;
+                case 0x37124:
+                    f10 = r3;
+                    f0 = r3;
+                    f11 = r2;
+                    f1 = r2;
+                    f4 = r3;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f5 = r2;
+                    f8 = readPages[(r28+-31220)>>>12][((r28+-31220)>>>2)&0x3ff];
+                    f10 = readPages[(r28+-31172)>>>12][((r28+-31172)>>>2)&0x3ff];
+                    f9 = readPages[(r28+-31224)>>>12][((r28+-31224)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f4 = readPages[(r28+-31228)>>>12][((r28+-31228)>>>2)&0x3ff];
+                    f11 = readPages[(r28+-31176)>>>12][((r28+-31176)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31232)>>>12][((r28+-31232)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f8 = readPages[(r28+-31212)>>>12][((r28+-31212)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f9 = readPages[(r28+-31216)>>>12][((r28+-31216)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f8 = readPages[(r28+-31204)>>>12][((r28+-31204)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f9 = readPages[(r28+-31208)>>>12][((r28+-31208)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f8 = readPages[(r28+-31196)>>>12][((r28+-31196)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f9 = readPages[(r28+-31200)>>>12][((r28+-31200)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f8 = readPages[(r28+-31188)>>>12][((r28+-31188)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f9 = readPages[(r28+-31192)>>>12][((r28+-31192)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f8 = readPages[(r28+-31180)>>>12][((r28+-31180)>>>2)&0x3ff];
+                    f9 = readPages[(r28+-31184)>>>12][((r28+-31184)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f10 = readPages[(r28+-31164)>>>12][((r28+-31164)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f11 = readPages[(r28+-31168)>>>12][((r28+-31168)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f10 = readPages[(r28+-31156)>>>12][((r28+-31156)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f11 = readPages[(r28+-31160)>>>12][((r28+-31160)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f10 = readPages[(r28+-31148)>>>12][((r28+-31148)>>>2)&0x3ff];
+                case 0x37200:
+                    pc=0x37200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_37200() throws ExecutionException { /* 0x37200 - 0x37400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x37200:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f11 = readPages[(r28+-31152)>>>12][((r28+-31152)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f10 = readPages[(r28+-31140)>>>12][((r28+-31140)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f11 = readPages[(r28+-31144)>>>12][((r28+-31144)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f10 = r5;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    f11 = r4;
+                    r4 = 16357 << 16;
+                    r4 = r4 | 37928;
+                    r10 = r10 < r4 ? 1 : 0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r28+-31132)>>>12][((r28+-31132)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31136)>>>12][((r28+-31136)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f0 = r3;
+                    f1 = r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    if(r10 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37308;
+                        continue;
+                    }
+                    r5 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    if(r5 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x373a8;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-31252)>>>12][((r28+-31252)>>>2)&0x3ff];
+                    r4 = f5;
+                    f1 = readPages[(r28+-31256)>>>12][((r28+-31256)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = r5;
+                    f10 = r3;
+                    r9 = r0 + r0;
+                    f3 = r4;
+                    f11 = r2;
+                    f8 = r9;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f10 = readPages[(r28+-31260)>>>12][((r28+-31260)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f11 = readPages[(r28+-31264)>>>12][((r28+-31264)>>>2)&0x3ff];
+                    r8 = f5;
+                    f9 = r8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x372f8:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37308:
+                    f2 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r6 = r6 >> 30;
+                    { long l = Double.doubleToLongBits(((double)f2)); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r6 = r6 & 2;
+                    r4 = r0 + 1;
+                    r6 = r4 - r6;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))/(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f10 = r6;
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits(((double)f10)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r29 = r29 + 24;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    f4 = r3;
+                    f5 = r2;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f9 = (int)(l >>> 32); f8 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37368:
+                    /* Next insn is delay slot */ 
+                    r31=0x37370;
+                    pc=0x32a00;
+                    run_32a00(); return;
+                case 0x37370:
+                    f4 = readPages[(r28+-31260)>>>12][((r28+-31260)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-31264)>>>12][((r28+-31264)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x372f8;
+                    continue;
+                case 0x3738c:
+                    r11 = 32768 << 16;
+                    r8 = r2 ^ r11;
+                    r2 = r8 + r0;
+                    r8 = r4 ^ r11;
+                    r4 = r8 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x370e8;
+                    run_37000(); return;
+                case 0x373a8:
+                    f0 = f4;
+                    f1 = f5;
+                    /* Next insn is delay slot */ 
+                    pc=0x372f8;
+                    continue;
+                case 0x373b4:
+                    f0 = r3;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x372f8;
+                    continue;
+                case 0x37400:
+                    pc=0x37400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_37400() throws ExecutionException { /* 0x37400 - 0x37600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x37400:
+                    r2 = f13;
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r2 = r3 & r2;
+                    r3 = 32784 << 16;
+                    r2 = r2 + r3;
+                    r2 = r2 >>> 31;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37600:
+                    pc=0x37600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_37600() throws ExecutionException { /* 0x37600 - 0x37800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x37600:
+                    r2 = f13;
+                    r3 = f12;
+                    r5 = r2 >> 20;
+                    r5 = r5 & 2047;
+                    r4 = r5 + -1023;
+                    r7 = r4 < 20 ? 1 : 0;
+                    r8 = r2 + r0;
+                    r9 = r2 + r0;
+                    r6 = r3 + r0;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x376ac;
+                        continue;
+                    }
+                    if(r4 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37740;
+                        continue;
+                    }
+                    r5 = 15 << 16;
+                    r5 = r5 | 65535;
+                    r5 = r5 >> (r4&0x1f);
+                    r7 = r5 & r2;
+                    r7 = r7 | r3;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x376c4;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-31124)>>>12][((r28+-31124)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31128)>>>12][((r28+-31128)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f0 = r0;
+                    f1 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37698;
+                        continue;
+                    }
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37798;
+                        continue;
+                    }
+                case 0x3768c:
+                    r8 = ~(r0 | r5);
+                    r8 = r9 & r8;
+                    r6 = r0 + r0;
+                case 0x37698:
+                    f0 = r6;
+                    f1 = r8;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x376ac:
+                    r7 = r4 < 52 ? 1 : 0;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x376d0;
+                        continue;
+                    }
+                    r2 = r0 + 1024;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3778c;
+                        continue;
+                    }
+                case 0x376c4:
+                    f0 = f12;
+                    f1 = f13;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x376d0:
+                    r10 = r0 + -1;
+                    r7 = r5 + -1043;
+                    r7 = r10 >>> (r7&0x1f);
+                    r10 = r7 & r3;
+                    if(r10 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x376c4;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-31124)>>>12][((r28+-31124)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31128)>>>12][((r28+-31128)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f0 = r0;
+                    f1 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37698;
+                        continue;
+                    }
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x377ac;
+                        continue;
+                    }
+                case 0x37724:
+                    r7 = ~(r0 | r7);
+                    r6 = r6 & r7;
+                    f0 = r6;
+                    r8 = r9 + r0;
+                    f1 = r8;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37740:
+                    f0 = readPages[(r28+-31124)>>>12][((r28+-31124)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31128)>>>12][((r28+-31128)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f13 = (int)(l >>> 32); f12 = (int)l; }
+                    f0 = r0;
+                    f1 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37698;
+                        continue;
+                    }
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x377e4;
+                        continue;
+                    }
+                    r6 = r0 + r0;
+                    r8 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x37698;
+                    continue;
+                case 0x3778c:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37798:
+                    r9 = 16 << 16;
+                    r4 = r9 >> (r4&0x1f);
+                    r9 = r4 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x3768c;
+                    continue;
+                case 0x377ac:
+                    r8 = r0 + 20;
+                    if(r4 == r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x377d8;
+                        continue;
+                    }
+                    r6 = r0 + 1075;
+                    r5 = r6 - r5;
+                    r6 = r0 + 1;
+                    r6 = r6 << (r5&0x1f);
+                    r6 = r6 + r3;
+                    r4 = ((r6 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37724;
+                        continue;
+                    }
+                case 0x377d8:
+                    r9 = r2 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x37724;
+                    continue;
+                case 0x377e4:
+                    r4 = 32767 << 16;
+                    r4 = r4 | 65535;
+                    r2 = r4 & r2;
+                    r2 = r2 | r3;
+                    r6 = r0 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37698;
+                        continue;
+                    }
+                case 0x37800:
+                    pc=0x37800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_37800() throws ExecutionException { /* 0x37800 - 0x37a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x37800:
+                    r8 = 49136 << 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x37698;
+                    run_37600(); return;
+                case 0x37a00:
+                    pc=0x37a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_37a00() throws ExecutionException { /* 0x37a00 - 0x37c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x37a00:
+                    r4 = f13;
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r3 = r3 & r4;
+                    r5 = f12;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37a40;
+                        continue;
+                    }
+                    r2 = 65520 << 16;
+                    r2 = r3 + r2;
+                    r6 = 32736 << 16;
+                    r2 = ((r2 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37a54;
+                        continue;
+                    }
+                    r2 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37a40:
+                    r2 = (r5&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r3 = r0 + 3;
+                    r2 = r3 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37a54:
+                    r2 = 16 << 16;
+                    r2 = ((r3 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37a70;
+                        continue;
+                    }
+                    r2 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37a70:
+                    r2 = 32752 << 16;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x37a88;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37a88:
+                    r2 = (r5&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37c00:
+                    pc=0x37c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_37c00() throws ExecutionException { /* 0x37c00 - 0x37e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x37c00:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x37e00:
+                    pc=0x37e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_37e00() throws ExecutionException { /* 0x37e00 - 0x38000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x37e00:
+                    r3 = r0 + r0;
+                    f0 = r3;
+                    r2 = 32760 << 16;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x38000:
+                    pc=0x38000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_38000() throws ExecutionException { /* 0x38000 - 0x38200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x38000:
+                    r2 = f13;
+                    r29 = r29 + -8;
+                    r5 = r2 >> 20;
+                    r5 = r5 & 2047;
+                    r4 = r5 + -1023;
+                    r7 = r4 < 20 ? 1 : 0;
+                    r3 = f12;
+                    r9 = r2 + r0;
+                    r6 = r2 >>> 31;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x38090;
+                        continue;
+                    }
+                    if(r4 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x38144;
+                        continue;
+                    }
+                    r5 = 15 << 16;
+                    r5 = r5 | 65535;
+                    r5 = r5 >> (r4&0x1f);
+                    r7 = r5 & r2;
+                    r7 = r7 | r3;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x380a8;
+                        continue;
+                    }
+                    r5 = r5 >>> 1;
+                    r7 = r5 & r2;
+                    r7 = r7 | r3;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x381f4;
+                        continue;
+                    }
+                    r7 = r0 + 19;
+                    if(r4 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3820c;
+                        run_38200(); return;
+                    }
+                    r8 = r0 + r0;
+                case 0x38074:
+                    r9 = 4 << 16;
+                    r5 = ~(r0 | r5);
+                    r2 = r5 & r2;
+                    r4 = r9 >> (r4&0x1f);
+                    r9 = r2 | r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x380f8;
+                    continue;
+                case 0x38090:
+                    r7 = r4 < 52 ? 1 : 0;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x380b8;
+                        continue;
+                    }
+                    r2 = r0 + 1024;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x38200;
+                        run_38200(); return;
+                    }
+                case 0x380a8:
+                    f0 = f12;
+                    f1 = f13;
+                case 0x380ac:
+                    r29 = r29 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x380b8:
+                    r5 = r5 + -1043;
+                    r4 = r0 + -1;
+                    r4 = r4 >>> (r5&0x1f);
+                    r7 = r4 & r3;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x380a8;
+                        continue;
+                    }
+                    r4 = r4 >>> 1;
+                    r7 = r4 & r3;
+                    r8 = r3 + r0;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x380f8;
+                        continue;
+                    }
+                    r4 = ~(r0 | r4);
+                    r2 = 16384 << 16;
+                    r8 = r4 & r3;
+                    r5 = r2 >> (r5&0x1f);
+                    r8 = r8 | r5;
+                case 0x380f8:
+                    r2 = 7 << 16;
+                    r6 = r6 << 3;
+                    r2 = r2 + 192;
+                    r6 = r6 + r2;
+                    f2 = r8;
+                    f0 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    f3 = r9;
+                    f1 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+4)>>>12][((r29+4)>>>2)&0x3ff] = f2;
+                    writePages[(r29+0)>>>12][((r29+0)>>>2)&0x3ff] = f3;
+                    f12 = readPages[(r29+4)>>>12][((r29+4)>>>2)&0x3ff];
+                    f13 = readPages[(r29+0)>>>12][((r29+0)>>>2)&0x3ff];
+                    r29 = r29 + 8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x38144:
+                    r7 = 32767 << 16;
+                    r7 = r7 | 65535;
+                    r4 = r7 & r2;
+                    r4 = r4 | r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x380a8;
+                        continue;
+                    }
+                    r4 = 15 << 16;
+                    r4 = r4 | 65535;
+                    r4 = r4 & r2;
+                    r3 = r4 | r3;
+                    r8 = r0 - r3;
+                    r3 = r8 | r3;
+                    r3 = r3 >>> 12;
+                    r8 = 8 << 16;
+                    r3 = r3 & r8;
+                    r8 = 65534 << 16;
+                    r2 = r8 & r2;
+                    r4 = r3 | r2;
+                    r2 = 7 << 16;
+                    r3 = r6 << 3;
+                    r5 = f12;
+                    r2 = r2 + 192;
+                    r2 = r3 + r2;
+                    f0 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f2 = r5;
+                    f1 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    f3 = r4;
+                    r6 = r6 << 31;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+4)>>>12][((r29+4)>>>2)&0x3ff] = f2;
+                    writePages[(r29+0)>>>12][((r29+0)>>>2)&0x3ff] = f3;
+                    f2 = readPages[(r29+4)>>>12][((r29+4)>>>2)&0x3ff];
+                    f3 = readPages[(r29+0)>>>12][((r29+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r4 = f1;
+                    r3 = f0;
+                    r4 = r7 & r4;
+                    f0 = r3;
+                    r2 = r6 | r4;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x380ac;
+                    continue;
+                case 0x381f4:
+                    r8 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x380f8;
+                    continue;
+                case 0x38200:
+                    pc=0x38200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_38200() throws ExecutionException { /* 0x38200 - 0x38400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x38200:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x380ac;
+                    run_38000(); return;
+                case 0x3820c:
+                    r8 = 32768 << 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x38074;
+                    run_38000(); return;
+                case 0x38400:
+                    pc=0x38400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_38400() throws ExecutionException { /* 0x38400 - 0x38600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x38400:
+                    r2 = f13;
+                    r5 = 32752 << 16;
+                    r4 = r5 & r2;
+                    r29 = r29 + -32;
+                    r4 = r4 >> 20;
+                    f14 = f12;
+                    f15 = f13;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f20;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f21;
+                    r3 = f12;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x384c8;
+                        continue;
+                    }
+                    r4 = 32767 << 16;
+                    r4 = r4 | 65535;
+                    r2 = r4 & r2;
+                    r2 = r2 | r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x38528;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-31108)>>>12][((r28+-31108)>>>2)&0x3ff];
+                    r4 = 65535 << 16;
+                    f1 = readPages[(r28+-31112)>>>12][((r28+-31112)>>>2)&0x3ff];
+                    r4 = r4 + 15536;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f15 = (int)(l >>> 32); f14 = (int)l; }
+                    r4 = r6 < r4 ? 1 : 0;
+                    r2 = f15;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x38544;
+                        continue;
+                    }
+                    r4 = r5 & r2;
+                    r4 = r4 >> 20;
+                    r4 = r4 + -54;
+                    r7 = r4 + r6;
+                    r8 = r2 + r0;
+                    r2 = r7 < 2047 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x384e8;
+                        continue;
+                    }
+                case 0x3848c:
+                    f20 = readPages[(r28+-31092)>>>12][((r28+-31092)>>>2)&0x3ff];
+                    f21 = readPages[(r28+-31096)>>>12][((r28+-31096)>>>2)&0x3ff];
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x384a8;
+                    pc=0x38800;
+                    run_38800(); return;
+                case 0x384a8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x384c8:
+                    r8 = r2 + r0;
+                    r2 = r0 + 2047;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x385ac;
+                        continue;
+                    }
+                    r7 = r4 + r6;
+                    r2 = r7 < 2047 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3848c;
+                        continue;
+                    }
+                case 0x384e8:
+                    if(r7 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x38568;
+                        continue;
+                    }
+                    r3 = f14;
+                    r4 = 32783 << 16;
+                    r4 = r4 | 65535;
+                    r7 = r7 << 20;
+                    r8 = r8 & r4;
+                    f0 = r3;
+                    r2 = r7 | r8;
+                    f1 = r2;
+                case 0x38510:
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x38528:
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    f0 = f12;
+                    f1 = f13;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x38544:
+                    f0 = readPages[(r28+-31100)>>>12][((r28+-31100)>>>2)&0x3ff];
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31104)>>>12][((r28+-31104)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f15&0xffffffffL) << 32) | (f14&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x38568:
+                    r2 = r7 < -53 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x385c8;
+                        continue;
+                    }
+                    r2 = r0 | 50001;
+                    r6 = r6 < r2 ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3848c;
+                        continue;
+                    }
+                    f20 = readPages[(r28+-31100)>>>12][((r28+-31100)>>>2)&0x3ff];
+                    f21 = readPages[(r28+-31104)>>>12][((r28+-31104)>>>2)&0x3ff];
+                    f12 = f20;
+                    f13 = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x385a0;
+                    pc=0x38800;
+                    run_38800(); return;
+                case 0x385a0:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x38510;
+                    continue;
+                case 0x385ac:
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))+(Double.longBitsToDouble(((f13&0xffffffffL) << 32) | (f12&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x385c8:
+                    r5 = f14;
+                    r2 = 32783 << 16;
+                    r7 = r7 + 54;
+                    r2 = r2 | 65535;
+                    r7 = r7 << 20;
+                    r8 = r8 & r2;
+                    f2 = r5;
+                    f0 = readPages[(r28+-31084)>>>12][((r28+-31084)>>>2)&0x3ff];
+                    r4 = r7 | r8;
+                    f3 = r4;
+                    f1 = readPages[(r28+-31088)>>>12][((r28+-31088)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x38510;
+                    continue;
+                case 0x38600:
+                    pc=0x38600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_38600() throws ExecutionException { /* 0x38600 - 0x38800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x38600:
+                case 0x38800:
+                    pc=0x38800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_38800() throws ExecutionException { /* 0x38800 - 0x38a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x38800:
+                    r6 = f15;
+                    r5 = 32768 << 16;
+                    r6 = r5 & r6;
+                    r4 = f13;
+                    r3 = f12;
+                    r5 = 32767 << 16;
+                    r5 = r5 | 65535;
+                    r4 = r5 & r4;
+                    f0 = r3;
+                    r2 = r6 | r4;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x38a00:
+                    pc=0x38a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_38a00() throws ExecutionException { /* 0x38a00 - 0x38c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x38a00:
+                    r5 = r4 + r0;
+                    r6 = r0 + r0;
+                    r4 = r0 + r0;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x56a00;
+                    run_56a00(); return;
+                case 0x38c00:
+                    pc=0x38c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_38c00() throws ExecutionException { /* 0x38c00 - 0x38e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x38c00:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x38e00:
+                    pc=0x38e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_38e00() throws ExecutionException { /* 0x38e00 - 0x39000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x38e00:
+                    r29 = r29 + -24;
+                    r5 = r0 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x38e1c;
+                    pc=0x56c00;
+                    run_56c00(); return;
+                case 0x38e1c:
+                    r4 = readPages[(r28+-31076)>>>12][((r28+-31076)>>>2)&0x3ff];
+                    r2 = readPages[(r4+60)>>>12][((r4+60)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x38e3c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x38e3c;
+                    return;
+                case 0x38e3c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x38e48;
+                    pc=0x48800;
+                    run_48800(); return;
+                case 0x38e48:
+                case 0x39000:
+                    pc=0x39000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_39000() throws ExecutionException { /* 0x39000 - 0x39200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x39000:
+                    r29 = r29 + -32;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r16 = r5 + r0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3904c;
+                        continue;
+                    }
+                    r17 = r4 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3903c;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39138;
+                        continue;
+                    }
+                case 0x3903c:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3906c;
+                        continue;
+                    }
+                case 0x3904c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3906c:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3907c;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x3907c:
+                    r3 = readPages[(r16+44)>>>12][((r16+44)>>>2)&0x3ff];
+                    r18 = r2 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x390a4;
+                        continue;
+                    }
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    r31=0x3909c;
+                    return;
+                case 0x3909c:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39148;
+                        continue;
+                    }
+                case 0x390a4:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 128;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39154;
+                        continue;
+                    }
+                case 0x390b8:
+                    r5 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x390e4;
+                        continue;
+                    }
+                    r2 = r16 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x390e0;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x390e0;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x390e0:
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                case 0x390e4:
+                    r5 = readPages[(r16+68)>>>12][((r16+68)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39104;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x39100;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x39100:
+                    writePages[(r16+68)>>>12][((r16+68)>>>2)&0x3ff] = r0;
+                case 0x39104:
+                    /* Next insn is delay slot */ 
+                    r31=0x3910c;
+                    pc=0x3aa00;
+                    run_3aa00(); return;
+                case 0x3910c:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r0&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x39118;
+                    pc=0x3ac00;
+                    run_3ac00(); return;
+                case 0x39118:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r18 + r0;
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x39138:
+                    /* Next insn is delay slot */ 
+                    r31=0x39140;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x39140:
+                    /* Next insn is delay slot */ 
+                    pc=0x3903c;
+                    continue;
+                case 0x39148:
+                    r18 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x390a4;
+                    continue;
+                case 0x39154:
+                    r5 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x39164;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x39164:
+                    /* Next insn is delay slot */ 
+                    pc=0x390b8;
+                    continue;
+                case 0x39200:
+                    pc=0x39200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_39200() throws ExecutionException { /* 0x39200 - 0x39400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x39200:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x39000;
+                    run_39000(); return;
+                case 0x39400:
+                    pc=0x39400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_39400() throws ExecutionException { /* 0x39400 - 0x39600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x39400:
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -40;
+                    r3 = r2 & 8;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r19 = r4 + r0;
+                    r17 = r5 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39540;
+                        continue;
+                    }
+                    r3 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    r2 = r2 | 2048;
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x395f4;
+                        continue;
+                    }
+                case 0x39444:
+                    r3 = readPages[(r17+40)>>>12][((r17+40)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3951c;
+                        continue;
+                    }
+                    r2 = r2 & 65535;
+                    r4 = r2 & 4096;
+                    r16 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3960c;
+                        run_39600(); return;
+                    }
+                    r6 = readPages[(r17+80)>>>12][((r17+80)>>>2)&0x3ff];
+                case 0x39470:
+                    r2 = r2 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x394a4;
+                        continue;
+                    }
+                    r2 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r6 = r6 - r2;
+                    r2 = readPages[(r17+48)>>>12][((r17+48)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x394a4;
+                        continue;
+                    }
+                    r2 = readPages[(r17+60)>>>12][((r17+60)>>>2)&0x3ff];
+                    r6 = r6 - r2;
+                case 0x394a4:
+                    r5 = readPages[(r17+28)>>>12][((r17+28)>>>2)&0x3ff];
+                    r4 = r19 + r0;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    r31=0x394b8;
+                    return;
+                case 0x394b8:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39644;
+                        run_39600(); return;
+                    }
+                case 0x394c4:
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r4 = readPages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff];
+                    r3 = r3 & 63487;
+                    r3 = r3 << 16;
+                    r3 = r3 >> 16;
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r3 & 4096;
+                    writePages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff] = r0;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r4;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x396c8;
+                        run_39600(); return;
+                    }
+                case 0x394f0:
+                    r5 = readPages[(r17+48)>>>12][((r17+48)>>>2)&0x3ff];
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r16;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3951c;
+                        continue;
+                    }
+                    r2 = r17 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39518;
+                        continue;
+                    }
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x39518;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x39518:
+                    writePages[(r17+48)>>>12][((r17+48)>>>2)&0x3ff] = r0;
+                case 0x3951c:
+                    r2 = r0 + r0;
+                case 0x39520:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x39540:
+                    r18 = readPages[(r5+16)>>>12][((r5+16)>>>2)&0x3ff];
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3951c;
+                        continue;
+                    }
+                    r16 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r2 = r2 & 3;
+                    r16 = r16 - r18;
+                    writePages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff] = r18;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x395e8;
+                        continue;
+                    }
+                    r2 = readPages[(r5+20)>>>12][((r5+20)>>>2)&0x3ff];
+                case 0x39570:
+                    writePages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff] = r2;
+                    if(r16 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39594;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3951c;
+                    continue;
+                case 0x39584:
+                    r16 = r16 - r2;
+                    r18 = r18 + r2;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3951c;
+                        continue;
+                    }
+                case 0x39594:
+                    r2 = readPages[(r17+36)>>>12][((r17+36)>>>2)&0x3ff];
+                    r5 = readPages[(r17+28)>>>12][((r17+28)>>>2)&0x3ff];
+                    r4 = r19 + r0;
+                    r6 = r18 + r0;
+                    r7 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x395b0;
+                    return;
+                case 0x395b0:
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39584;
+                        continue;
+                    }
+                case 0x395b8:
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r2 | 64;
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x395e8:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x39570;
+                    continue;
+                case 0x395f4:
+                    r3 = readPages[(r5+60)>>>12][((r5+60)>>>2)&0x3ff];
+                    if(r3 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39444;
+                        continue;
+                    }
+                case 0x39600:
+                    pc=0x39600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_39600() throws ExecutionException { /* 0x39600 - 0x39800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x39600:
+                    /* Next insn is delay slot */ 
+                    pc=0x3951c;
+                    run_39400(); return;
+                case 0x3960c:
+                    r5 = readPages[(r17+28)>>>12][((r17+28)>>>2)&0x3ff];
+                    r6 = r0 + r0;
+                    r4 = r19 + r0;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    r31=0x39624;
+                    return;
+                case 0x39624:
+                    r6 = r2 + r0;
+                    r2 = r0 + -1;
+                    if(r6 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39690;
+                        continue;
+                    }
+                case 0x39634:
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = readPages[(r17+40)>>>12][((r17+40)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x39470;
+                    run_39400(); return;
+                case 0x39644:
+                    r3 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x394c4;
+                        run_39400(); return;
+                    }
+                    r2 = r0 + 29;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3966c;
+                        continue;
+                    }
+                    r2 = r0 + 22;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x395b8;
+                        run_39400(); return;
+                    }
+                case 0x3966c:
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    writePages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff] = r0;
+                    r2 = r2 & 63487;
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff];
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x394f0;
+                    run_39400(); return;
+                case 0x39690:
+                    r2 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39634;
+                        continue;
+                    }
+                    r3 = r0 + 29;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x396b8;
+                        continue;
+                    }
+                    r3 = r0 + 22;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x395b8;
+                        run_39400(); return;
+                    }
+                case 0x396b8:
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r16;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x39520;
+                    run_39400(); return;
+                case 0x396c8:
+                    writePages[(r17+80)>>>12][((r17+80)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x394f0;
+                    run_39400(); return;
+                case 0x39800:
+                    pc=0x39800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_39800() throws ExecutionException { /* 0x39800 - 0x39a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x39800:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39828;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39868;
+                        continue;
+                    }
+                case 0x39828:
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39850;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x39850:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x39400;
+                    run_39400(); return;
+                case 0x39868:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x39874;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x39874:
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x39828;
+                    continue;
+                case 0x39a00:
+                    pc=0x39a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_39a00() throws ExecutionException { /* 0x39a00 - 0x39c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x39a00:
+                    r5 = r4 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x39a18;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x39a18:
+                    r5 = 4 << 16;
+                    r4 = readPages[(r28+-31076)>>>12][((r28+-31076)>>>2)&0x3ff];
+                    r5 = r5 + -26624;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d800;
+                    run_3d800(); return;
+                case 0x39c00:
+                    pc=0x39c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_39c00() throws ExecutionException { /* 0x39c00 - 0x39e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x39c00:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x39e00:
+                    pc=0x39e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_39e00() throws ExecutionException { /* 0x39e00 - 0x3a000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x39e00:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3a000:
+                    pc=0x3a000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3a000() throws ExecutionException { /* 0x3a000 - 0x3a200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3a000:
+                    r5 = 4 << 16;
+                    r5 = r5 + -28160;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d600;
+                    run_3d600(); return;
+                case 0x3a200:
+                    pc=0x3a200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3a200() throws ExecutionException { /* 0x3a200 - 0x3a400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3a200:
+                    r29 = r29 + -32;
+                    r2 = r5 << 2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    r18 = r5 << 4;
+                    r18 = r18 - r2;
+                    r18 = r18 + r5;
+                    r18 = r18 << 3;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r17 = r5 + r0;
+                    r5 = r18 + 12;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x3a238;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x3a238:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3a264;
+                        continue;
+                    }
+                    r4 = r2 + 12;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r17;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r4;
+                    r5 = r0 + r0;
+                    r6 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3a264;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x3a264:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3a400:
+                    pc=0x3a400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3a400() throws ExecutionException { /* 0x3a400 - 0x3a600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3a400:
+                    r5 = 4 << 16;
+                    r4 = readPages[(r28+-31076)>>>12][((r28+-31076)>>>2)&0x3ff];
+                    r5 = r5 + -28160;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d600;
+                    run_3d600(); return;
+                case 0x3a600:
+                    pc=0x3a600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3a600() throws ExecutionException { /* 0x3a600 - 0x3a800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3a600:
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    r29 = r29 + -48;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r17 = r4 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3a77c;
+                        continue;
+                    }
+                    r2 = 4 << 16;
+                    r2 = r2 + -24576;
+                    writePages[(r4+60)>>>12][((r4+60)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 3;
+                    r16 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    writePages[(r4+740)>>>12][((r4+740)>>>2)&0x3ff] = r2;
+                    r2 = r4 + 748;
+                    writePages[(r4+744)>>>12][((r4+744)>>>2)&0x3ff] = r2;
+                    r22 = r0 + 1;
+                    r2 = r0 + 4;
+                    r21 = 4 << 16;
+                    r20 = 4 << 16;
+                    r19 = 4 << 16;
+                    r18 = 4 << 16;
+                    writePages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff] = r22;
+                    writePages[(r4+736)>>>12][((r4+736)>>>2)&0x3ff] = r0;
+                    r21 = r21 + 8704;
+                    r4 = r16 + 92;
+                    r20 = r20 + 9728;
+                    r19 = r19 + 10240;
+                    r18 = r18 + 10752;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r0;
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r0&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r0;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r0;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    r31=0x3a6bc;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x3a6bc:
+                    writePages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff] = r16;
+                    writePages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff] = r21;
+                    writePages[(r16+36)>>>12][((r16+36)>>>2)&0x3ff] = r20;
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r19;
+                    writePages[(r16+44)>>>12][((r16+44)>>>2)&0x3ff] = r18;
+                    r16 = readPages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff];
+                    r2 = r0 + 8;
+                    r4 = r16 + 92;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r0;
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r22&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r0;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r0;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    r31=0x3a710;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x3a710:
+                    writePages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff] = r16;
+                    writePages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff] = r21;
+                    writePages[(r16+36)>>>12][((r16+36)>>>2)&0x3ff] = r20;
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r19;
+                    writePages[(r16+44)>>>12][((r16+44)>>>2)&0x3ff] = r18;
+                    r16 = readPages[(r17+12)>>>12][((r17+12)>>>2)&0x3ff];
+                    r2 = r0 + 18;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 2;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r0;
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r0;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r0;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    r4 = r16 + 92;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    r31=0x3a768;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x3a768:
+                    writePages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff] = r16;
+                    writePages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff] = r21;
+                    writePages[(r16+36)>>>12][((r16+36)>>>2)&0x3ff] = r20;
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r19;
+                    writePages[(r16+44)>>>12][((r16+44)>>>2)&0x3ff] = r18;
+                case 0x3a77c:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3a800:
+                    pc=0x3a800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3a800() throws ExecutionException { /* 0x3a800 - 0x3aa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3a800:
+                    r29 = r29 + -40;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    r18 = readPages[(r28+-31076)>>>12][((r28+-31076)>>>2)&0x3ff];
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r2 = readPages[(r18+56)>>>12][((r18+56)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r19 = r4 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3a900;
+                        continue;
+                    }
+                case 0x3a82c:
+                    r18 = r18 + 736;
+                    r17 = r0 + -1;
+                case 0x3a834:
+                    r2 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    r16 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3a860;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3a8e4;
+                    continue;
+                case 0x3a850:
+                    r2 = r2 + -1;
+                    r16 = r16 + 104;
+                    if(r2 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3a8e4;
+                        continue;
+                    }
+                case 0x3a860:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3a850;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 1;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r0;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r0;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r0;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    r4 = r16 + 92;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    r31=0x3a8b0;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x3a8b0:
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                    writePages[(r16+52)>>>12][((r16+52)>>>2)&0x3ff] = r0;
+                    writePages[(r16+68)>>>12][((r16+68)>>>2)&0x3ff] = r0;
+                    writePages[(r16+72)>>>12][((r16+72)>>>2)&0x3ff] = r0;
+                    r2 = r16 + r0;
+                case 0x3a8c4:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3a8e4:
+                    r2 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3a914;
+                        continue;
+                    }
+                case 0x3a8f4:
+                    r18 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3a834;
+                    continue;
+                case 0x3a900:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3a90c;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x3a90c:
+                    /* Next insn is delay slot */ 
+                    pc=0x3a82c;
+                    continue;
+                case 0x3a914:
+                    r4 = r19 + r0;
+                    r5 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    r31=0x3a924;
+                    pc=0x3a200;
+                    run_3a200(); return;
+                case 0x3a924:
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3a8f4;
+                        continue;
+                    }
+                    r2 = r0 + 12;
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3a8c4;
+                    continue;
+                case 0x3aa00:
+                    pc=0x3aa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3aa00() throws ExecutionException { /* 0x3aa00 - 0x3ac00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3aa00:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3ac00:
+                    pc=0x3ac00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3ac00() throws ExecutionException { /* 0x3ac00 - 0x3ae00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3ac00:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3ae00:
+                    pc=0x3ae00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3ae00() throws ExecutionException { /* 0x3ae00 - 0x3b000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3ae00:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3b000:
+                    pc=0x3b000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3b000() throws ExecutionException { /* 0x3b000 - 0x3b200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3b000:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3b200:
+                    pc=0x3b200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3b200() throws ExecutionException { /* 0x3b200 - 0x3b400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3b200:
+                    r5 = 4 << 16;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r5 + -25600;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d600;
+                    run_3d600(); return;
+                case 0x3b400:
+                    pc=0x3b400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3b400() throws ExecutionException { /* 0x3b400 - 0x3b600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3b400:
+                    r5 = 4 << 16;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r5 + -25088;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d600;
+                    run_3d600(); return;
+                case 0x3b600:
+                    pc=0x3b600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3b600() throws ExecutionException { /* 0x3b600 - 0x3b800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3b600:
+                    r29 = r29 + -48;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    r19 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r29 + 16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    r18 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3b630;
+                    pc=0x59600;
+                    run_59600(); return;
+                case 0x3b630:
+                    r17 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3b6f4;
+                        continue;
+                    }
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3b648;
+                    pc=0x3a800;
+                    run_3a800(); return;
+                case 0x3b648:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3b6f4;
+                        continue;
+                    }
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    r5 = r19 + r0;
+                    r7 = r0 + 438;
+                    /* Next insn is delay slot */ 
+                    r31=0x3b66c;
+                    pc=0x48820;
+                    run_48800(); return;
+                case 0x3b66c:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3b6e0;
+                        continue;
+                    }
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = 4 << 16;
+                    r2 = r2 + 8704;
+                    writePages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff] = r2;
+                    r2 = 4 << 16;
+                    r2 = r2 + 9728;
+                    writePages[(r16+36)>>>12][((r16+36)>>>2)&0x3ff] = r2;
+                    r2 = 4 << 16;
+                    r2 = r2 + 10240;
+                    writePages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff] = r2;
+                    r2 = 4 << 16;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r17&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r2 + 10752;
+                    r17 = r17 & 256;
+                    writePages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff] = r16;
+                    writePages[(r16+44)>>>12][((r16+44)>>>2)&0x3ff] = r2;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3b718;
+                        continue;
+                    }
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3b6e0:
+                    /* Next insn is delay slot */ 
+                    r31=0x3b6e8;
+                    pc=0x3aa00;
+                    run_3aa00(); return;
+                case 0x3b6e8:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r0&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x3b6f4;
+                    pc=0x3ac00;
+                    run_3ac00(); return;
+                case 0x3b6f4:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3b718:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r0 + r0;
+                    r7 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    r31=0x3b730;
+                    pc=0x3ce00;
+                    run_3ce00(); return;
+                case 0x3b730:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3b800:
+                    pc=0x3b800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3b800() throws ExecutionException { /* 0x3b800 - 0x3ba00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3b800:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3b600;
+                    run_3b600(); return;
+                case 0x3ba00:
+                    pc=0x3ba00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3ba00() throws ExecutionException { /* 0x3ba00 - 0x3bc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3ba00:
+                    r29 = r29 + -32;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r7;
+                    r7 = r29 + 44;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x3ba1c;
+                    pc=0x45c00;
+                    run_45c00(); return;
+                case 0x3ba1c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3bc00:
+                    pc=0x3bc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3bc00() throws ExecutionException { /* 0x3bc00 - 0x3be00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3bc00:
+                    r29 = r29 + -32;
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r6;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r7;
+                    r6 = r5 + r0;
+                    r7 = r29 + 40;
+                    r5 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x3bc30;
+                    pc=0x45c00;
+                    run_45c00(); return;
+                case 0x3bc30:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3be00:
+                    pc=0x3be00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3be00() throws ExecutionException { /* 0x3be00 - 0x3c000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3be00:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3be40;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3be40;
+                        continue;
+                    }
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x3be38;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x3be38:
+                    r6 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x3be40:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x3fe00;
+                    run_3fe00(); return;
+                case 0x3c000:
+                    pc=0x3c000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3c000() throws ExecutionException { /* 0x3c000 - 0x3c200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3c000:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r6 = r5 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c05c;
+                        continue;
+                    }
+                    r3 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c044;
+                        continue;
+                    }
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c03c;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x3c03c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x3c044:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x3fe00;
+                    run_3fe00(); return;
+                case 0x3c05c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x3fe00;
+                    run_3fe00(); return;
+                case 0x3c200:
+                    pc=0x3c200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3c200() throws ExecutionException { /* 0x3c200 - 0x3c400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3c200:
+                    { long hilo = (long)(r7) * ((long)r6); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r29 = r29 + -64;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r21;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r23;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r22;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r30;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    r21 = lo;
+                    r22 = r6 + r0;
+                    r23 = r7 + r0;
+                    r16 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c380;
+                        continue;
+                    }
+                    r20 = r4 + r0;
+                    r18 = r5 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c268;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c4b8;
+                        run_3c400(); return;
+                    }
+                case 0x3c268:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r2 = r3 & 65535;
+                    r4 = r2 & 8192;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c29c;
+                        continue;
+                    }
+                case 0x3c280:
+                    r4 = readPages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff];
+                    r2 = r3 | 8192;
+                    r3 = r0 + -8193;
+                    r3 = r4 & r3;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r3;
+                    r2 = r2 & 65535;
+                case 0x3c29c:
+                    r17 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    if(r17 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c3a8;
+                        continue;
+                    }
+                    r2 = r2 & 2;
+                    r3 = r17 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c3c0;
+                        continue;
+                    }
+                case 0x3c2bc:
+                    r19 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3c308;
+                    continue;
+                case 0x3c2c8:
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c2d4;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x3c2d4:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r2 = r2 + r17;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r5 = r16 + r0;
+                    r18 = r18 + r17;
+                    r19 = r19 - r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c2f8;
+                    pc=0x41200;
+                    run_41200(); return;
+                case 0x3c2f8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c38c;
+                        continue;
+                    }
+                    r17 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                case 0x3c308:
+                    r3 = ((r17 & 0xffffffffL) < (r19 & 0xffffffffL)) ? 1 : 0;
+                    r4 = r18 + r0;
+                    r5 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c2c8;
+                        continue;
+                    }
+                    r6 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c328;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x3c328:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r2 - r19;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r19 = r2 + r19;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r19;
+                case 0x3c348:
+                    r2 = r23 + r0;
+                case 0x3c34c:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3c380:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3c34c;
+                    continue;
+                case 0x3c38c:
+                    r2 = r21 - r19;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r22!=0) {
+                        hi = (int)((r2 & 0xffffffffL) % (r22 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r22 & 0xffffffffL));
+                        }
+                        pc=0x3c39c;
+                        continue;
+                    }
+                    if(r22!=0) {
+                    hi = (int)((r2 & 0xffffffffL) % (r22 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r22 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x3c39c:
+                    r2 = lo;
+                    /* Next insn is delay slot */ 
+                    pc=0x3c34c;
+                    continue;
+                case 0x3c3a8:
+                    r2 = r2 & 2;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    r3 = r0 + r0;
+                    r17 = r0 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c2bc;
+                        continue;
+                    }
+                case 0x3c3c0:
+                    r2 = ((r21 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    r17 = r3 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c3d4;
+                        continue;
+                    }
+                    r17 = r21 + r0;
+                case 0x3c3d4:
+                    r5 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c3e8;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x3c3e8:
+                    r19 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r5 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    r19 = r19 + r17;
+                    r2 = r2 - r17;
+                    r18 = r18 + r17;
+                case 0x3c400:
+                    pc=0x3c400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3c400() throws ExecutionException { /* 0x3c400 - 0x3c600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3c400:
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r19;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r17 = r21 - r17;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c4e0;
+                        continue;
+                    }
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c348;
+                        run_3c200(); return;
+                    }
+                    r2 = r16 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c438;
+                        continue;
+                    }
+                    r4 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c434;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x3c434:
+                    r19 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                case 0x3c438:
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                case 0x3c43c:
+                    r3 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r30 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x3c458;
+                    continue;
+                case 0x3c450:
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c348;
+                        run_3c200(); return;
+                    }
+                case 0x3c458:
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r18;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r17;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r18;
+                    r4 = r20 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c474;
+                    pc=0x41200;
+                    run_41200(); return;
+                case 0x3c474:
+                    r4 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r30;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r3;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r19;
+                    r17 = r17 - r4;
+                    r18 = r18 + r4;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c450;
+                        continue;
+                    }
+                    r2 = r21 - r17;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r22!=0) {
+                        hi = (int)((r2 & 0xffffffffL) % (r22 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r22 & 0xffffffffL));
+                        }
+                        pc=0x3c4ac;
+                        continue;
+                    }
+                    if(r22!=0) {
+                    hi = (int)((r2 & 0xffffffffL) % (r22 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r22 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x3c4ac:
+                    r2 = lo;
+                    /* Next insn is delay slot */ 
+                    pc=0x3c34c;
+                    run_3c200(); return;
+                case 0x3c4b8:
+                    /* Next insn is delay slot */ 
+                    r31=0x3c4c0;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x3c4c0:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r2 = r3 & 65535;
+                    r4 = r2 & 8192;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c29c;
+                        run_3c200(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3c280;
+                    run_3c200(); return;
+                case 0x3c4e0:
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c43c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3c348;
+                    run_3c200(); return;
+                case 0x3c600:
+                    pc=0x3c600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3c600() throws ExecutionException { /* 0x3c600 - 0x3c800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3c600:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r8 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c630;
+                    pc=0x3c200;
+                    run_3c200(); return;
+                case 0x3c630:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3c800:
+                    pc=0x3c800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3c800() throws ExecutionException { /* 0x3c800 - 0x3ca00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3c800:
+                    r29 = r29 + -40;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r18 = 7 << 16;
+                    r17 = r4 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    r20 = r5 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r18 = r18 + 11104;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c834;
+                    pc=0x48b80;
+                    run_48a00(); return;
+                case 0x3c834:
+                    r4 = r17 + r0;
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c844;
+                    pc=0x3f600;
+                    run_3f600(); return;
+                case 0x3c844:
+                    r2 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r19 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r0 + -4;
+                    r19 = r19 & r2;
+                    r5 = r19 - r20;
+                    r5 = r5 + -17;
+                    r5 = r5 + r16;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r16!=0) {
+                        hi = (int)((r5 & 0xffffffffL) % (r16 & 0xffffffffL)); lo = (int)((r5 & 0xffffffffL) / (r16 & 0xffffffffL));
+                        }
+                        pc=0x3c870;
+                        continue;
+                    }
+                    if(r16!=0) {
+                    hi = (int)((r5 & 0xffffffffL) % (r16 & 0xffffffffL)); lo = (int)((r5 & 0xffffffffL) / (r16 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x3c870:
+                    r20 = lo;
+                    r20 = r20 + -1;
+                    { long hilo = (long)(r20) * ((long)r16); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r20 = lo;
+                    r16 = r20 < r16 ? 1 : 0;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c8b4;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c8a0;
+                    pc=0x48920;
+                    run_48800(); return;
+                case 0x3c8a0:
+                    r3 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r3 = r3 + r19;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c8e8;
+                        continue;
+                    }
+                case 0x3c8b4:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c8c0;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3c8c0:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3c8e8:
+                    r4 = r17 + r0;
+                    r5 = r0 - r20;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c8f8;
+                    pc=0x48920;
+                    run_48800(); return;
+                case 0x3c8f8:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c958;
+                        continue;
+                    }
+                    r2 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r19 = r19 - r20;
+                    r19 = r19 | 1;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r19;
+                    r2 = 7 << 16;
+                    r3 = readPages[(r2+17968)>>>12][((r2+17968)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r20 = r3 - r20;
+                    writePages[(r2+17968)>>>12][((r2+17968)>>>2)&0x3ff] = r20;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c930;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3c930:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3c958:
+                    r4 = r17 + r0;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3c968;
+                    pc=0x48920;
+                    run_48800(); return;
+                case 0x3c968:
+                    r3 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r4 = r2 - r3;
+                    r5 = r4 < 16 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3c8b4;
+                        continue;
+                    }
+                    r5 = readPages[(r28+-31068)>>>12][((r28+-31068)>>>2)&0x3ff];
+                    r4 = r4 | 1;
+                    r2 = r2 - r5;
+                    r5 = 7 << 16;
+                    writePages[(r5+17968)>>>12][((r5+17968)>>>2)&0x3ff] = r2;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x3c8b4;
+                    continue;
+                case 0x3ca00:
+                    pc=0x3ca00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3ca00() throws ExecutionException { /* 0x3ca00 - 0x3cc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3ca00:
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r16 = r5 + r0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cba0;
+                        continue;
+                    }
+                    r17 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3ca28;
+                    pc=0x3f600;
+                    run_3f600(); return;
+                case 0x3ca28:
+                    r8 = readPages[(r16+-4)>>>12][((r16+-4)>>>2)&0x3ff];
+                    r2 = r0 + -2;
+                    r6 = r16 + -8;
+                    r2 = r8 & r2;
+                    r3 = r6 + r2;
+                    r5 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r7 = 7 << 16;
+                    r4 = r0 + -4;
+                    r7 = r7 + 11104;
+                    r5 = r5 & r4;
+                    r4 = readPages[(r7+8)>>>12][((r7+8)>>>2)&0x3ff];
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cc44;
+                        run_3cc00(); return;
+                    }
+                    r8 = r8 & 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r5;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cb64;
+                        continue;
+                    }
+                    r4 = r0 + r0;
+                case 0x3ca74:
+                    r8 = r3 + r5;
+                    r8 = readPages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff];
+                    r8 = r8 & 1;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3caac;
+                        continue;
+                    }
+                    r2 = r2 + r5;
+                    r5 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cc0c;
+                        run_3cc00(); return;
+                    }
+                case 0x3ca9c:
+                    r3 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    writePages[(r5+12)>>>12][((r5+12)>>>2)&0x3ff] = r3;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r5;
+                case 0x3caac:
+                    r3 = r2 | 1;
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = r3;
+                    r3 = r6 + r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cb48;
+                        continue;
+                    }
+                    r3 = (r2&0xffffffffL) < (512&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cbb8;
+                        continue;
+                    }
+                    r3 = r2 >>> 9;
+                    r4 = (r3&0xffffffffL) < (5&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ccb8;
+                        run_3cc00(); return;
+                    }
+                    r4 = r2 >>> 6;
+                    r4 = r4 + 56;
+                    r8 = r4 << 1;
+                case 0x3caec:
+                    r8 = r8 << 2;
+                    r8 = r7 + r8;
+                    r3 = readPages[(r8+8)>>>12][((r8+8)>>>2)&0x3ff];
+                    if(r3 == r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ccd4;
+                        run_3cc00(); return;
+                    }
+                    r4 = r0 + -4;
+                case 0x3cb08:
+                    r5 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r5 = r5 & r4;
+                    r5 = ((r2 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cb30;
+                        continue;
+                    }
+                    r3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r8 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cb08;
+                        continue;
+                    }
+                case 0x3cb30:
+                    r2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                case 0x3cb38:
+                    writePages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff] = r2;
+                    writePages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff] = r3;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r6;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r6;
+                case 0x3cb48:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3cb64:
+                    r4 = readPages[(r16+-8)>>>12][((r16+-8)>>>2)&0x3ff];
+                    r8 = 7 << 16;
+                    r6 = r6 - r4;
+                    r2 = r2 + r4;
+                    r4 = readPages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff];
+                    r8 = r8 + 11112;
+                    if(r4 == r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ccac;
+                        run_3cc00(); return;
+                    }
+                    r8 = readPages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = r8;
+                    writePages[(r8+8)>>>12][((r8+8)>>>2)&0x3ff] = r4;
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ca74;
+                    continue;
+                case 0x3cba0:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3cbb8:
+                    r2 = r2 >>> 3;
+                    r3 = r2 >> 2;
+                    r4 = r0 + 1;
+                    r3 = r4 << (r3&0x1f);
+                    r4 = readPages[(r7+4)>>>12][((r7+4)>>>2)&0x3ff];
+                    r2 = r2 << 3;
+                    r3 = r3 | r4;
+                    writePages[(r7+4)>>>12][((r7+4)>>>2)&0x3ff] = r3;
+                    r7 = r7 + r2;
+                    r2 = readPages[(r7+8)>>>12][((r7+8)>>>2)&0x3ff];
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    writePages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff] = r7;
+                    writePages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff] = r2;
+                    writePages[(r7+8)>>>12][((r7+8)>>>2)&0x3ff] = r6;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r6;
+                case 0x3cc00:
+                    pc=0x3cc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3cc00() throws ExecutionException { /* 0x3cc00 - 0x3ce00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3cc00:
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3cc0c:
+                    r8 = 7 << 16;
+                    r8 = r8 + 11112;
+                    if(r5 != r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ca9c;
+                        run_3ca00(); return;
+                    }
+                    r3 = r2 | 1;
+                    writePages[(r7+20)>>>12][((r7+20)>>>2)&0x3ff] = r6;
+                    writePages[(r7+16)>>>12][((r7+16)>>>2)&0x3ff] = r6;
+                    writePages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff] = r5;
+                    writePages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff] = r5;
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = r3;
+                    r6 = r6 + r2;
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x3cb48;
+                    run_3ca00(); return;
+                case 0x3cc44:
+                    r8 = r8 & 1;
+                    r2 = r5 + r2;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cc78;
+                        continue;
+                    }
+                    r3 = readPages[(r16+-8)>>>12][((r16+-8)>>>2)&0x3ff];
+                    r6 = r6 - r3;
+                    r4 = readPages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff];
+                    r2 = r2 + r3;
+                    r3 = readPages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = r3;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r4;
+                case 0x3cc78:
+                    r5 = readPages[(r28+-31064)>>>12][((r28+-31064)>>>2)&0x3ff];
+                    r3 = r2 | 1;
+                    r2 = ((r2 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = r3;
+                    writePages[(r7+8)>>>12][((r7+8)>>>2)&0x3ff] = r6;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cb48;
+                        run_3ca00(); return;
+                    }
+                    r5 = readPages[(r28+-30640)>>>12][((r28+-30640)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3cca4;
+                    pc=0x3c800;
+                    run_3c800(); return;
+                case 0x3cca4:
+                    /* Next insn is delay slot */ 
+                    pc=0x3cb48;
+                    run_3ca00(); return;
+                case 0x3ccac:
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ca74;
+                    run_3ca00(); return;
+                case 0x3ccb8:
+                    r4 = (r3&0xffffffffL) < (21&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ccfc;
+                        continue;
+                    }
+                    r4 = r3 + 91;
+                    r8 = r4 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3caec;
+                    run_3ca00(); return;
+                case 0x3ccd4:
+                    r2 = r0 + 1;
+                    r4 = r4 >> 2;
+                    r4 = r2 << (r4&0x1f);
+                    r2 = readPages[(r7+4)>>>12][((r7+4)>>>2)&0x3ff];
+                    r2 = r4 | r2;
+                    writePages[(r7+4)>>>12][((r7+4)>>>2)&0x3ff] = r2;
+                    r2 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3cb38;
+                    run_3ca00(); return;
+                case 0x3ccfc:
+                    r4 = (r3&0xffffffffL) < (85&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cd1c;
+                        continue;
+                    }
+                    r4 = r2 >>> 12;
+                    r4 = r4 + 110;
+                    r8 = r4 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3caec;
+                    run_3ca00(); return;
+                case 0x3cd1c:
+                    r4 = (r3&0xffffffffL) < (341&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cd3c;
+                        continue;
+                    }
+                    r4 = r2 >>> 15;
+                    r4 = r4 + 119;
+                    r8 = r4 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3caec;
+                    run_3ca00(); return;
+                case 0x3cd3c:
+                    r3 = (r3&0xffffffffL) < (1365&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cd5c;
+                        continue;
+                    }
+                    r4 = r2 >>> 18;
+                    r4 = r4 + 124;
+                    r8 = r4 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3caec;
+                    run_3ca00(); return;
+                case 0x3cd5c:
+                    r8 = r0 + 252;
+                    r4 = r0 + 126;
+                    /* Next insn is delay slot */ 
+                    pc=0x3caec;
+                    run_3ca00(); return;
+                case 0x3ce00:
+                    pc=0x3ce00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3ce00() throws ExecutionException { /* 0x3ce00 - 0x3d000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3ce00:
+                    r29 = r29 + -120;
+                    writePages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff] = r21;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r18;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r17;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r16;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r31;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r23;
+                    writePages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff] = r22;
+                    writePages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff] = r20;
+                    writePages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff] = r19;
+                    r17 = r4 + r0;
+                    r16 = r5 + r0;
+                    r21 = r6 + r0;
+                    r18 = r7 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ce50;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d030;
+                        run_3d000(); return;
+                    }
+                case 0x3ce50:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r2 = r0 + 264;
+                    r3 = r3 & 264;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d04c;
+                        run_3d000(); return;
+                    }
+                case 0x3ce64:
+                    r19 = readPages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff];
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d388;
+                        run_3d200(); return;
+                    }
+                    r2 = r0 + 1;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cfc4;
+                        continue;
+                    }
+                    r2 = r0 + 2;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ced4;
+                        continue;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ced4;
+                        continue;
+                    }
+                    r2 = r0 + 22;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                case 0x3ce9c:
+                    r20 = r0 + -1;
+                case 0x3cea0:
+                    r31 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r2 = r20 + r0;
+                    r23 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r22 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    r21 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r20 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    r19 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r18 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r17 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r16 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r29 = r29 + 120;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3ced4:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r22 = r0 + r0;
+                    r20 = r0 + r0;
+                case 0x3cee0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d324;
+                        run_3d200(); return;
+                    }
+                case 0x3cee8:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r2 = r3 & 65535;
+                    r4 = r2 & 2074;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cf24;
+                        continue;
+                    }
+                    r2 = r2 & 1024;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d0b8;
+                        run_3d000(); return;
+                    }
+                    r2 = 4 << 16;
+                    r2 = r2 + 10240;
+                    if(r19 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d064;
+                        run_3d000(); return;
+                    }
+                case 0x3cf1c:
+                    r3 = r3 | 2048;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x3cf24:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3cf34;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x3cf34:
+                    r20 = r2 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ce9c;
+                        continue;
+                    }
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r6 = r21 + r0;
+                    r7 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r19;
+                    r31=0x3cf58;
+                    return;
+                case 0x3cf58:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ce9c;
+                        continue;
+                    }
+                    r5 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cf90;
+                        continue;
+                    }
+                    r2 = r16 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cf8c;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3cf8c;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x3cf8c:
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                case 0x3cf90:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r4 = r16 + 92;
+                    r2 = r2 & 63455;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    r31=0x3cfbc;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x3cfbc:
+                    /* Next insn is delay slot */ 
+                    pc=0x3cea0;
+                    continue;
+                case 0x3cfc4:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3cfd4;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x3cfd4:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r2 & 4096;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d2e4;
+                        run_3d200(); return;
+                    }
+                    r20 = readPages[(r16+80)>>>12][((r16+80)>>>2)&0x3ff];
+                case 0x3cfec:
+                    r3 = r2 & 4;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d1a0;
+                        run_3d000(); return;
+                    }
+                    r2 = r2 & 8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d1c8;
+                        run_3d000(); return;
+                    }
+                case 0x3d000:
+                    pc=0x3d000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3d000() throws ExecutionException { /* 0x3d000 - 0x3d200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3d000:
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d01c;
+                        continue;
+                    }
+                    r3 = r3 - r2;
+                    r20 = r20 + r3;
+                case 0x3d01c:
+                    r21 = r21 + r20;
+                    r22 = r0 + 1;
+                    r18 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3cee0;
+                    run_3ce00(); return;
+                case 0x3d030:
+                    /* Next insn is delay slot */ 
+                    r31=0x3d038;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x3d038:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r2 = r0 + 264;
+                    r3 = r3 & 264;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ce64;
+                        run_3ce00(); return;
+                    }
+                case 0x3d04c:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3d05c;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x3d05c:
+                    /* Next insn is delay slot */ 
+                    pc=0x3ce64;
+                    run_3ce00(); return;
+                case 0x3d064:
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    if(r5 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cf1c;
+                        run_3ce00(); return;
+                    }
+                    r4 = r17 + r0;
+                    r6 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x3d084;
+                    pc=0x48960;
+                    run_48800(); return;
+                case 0x3d084:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d318;
+                        run_3d200(); return;
+                    }
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 | 32768;
+                    r3 = r3 & 61440;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d318;
+                        run_3d200(); return;
+                    }
+                    r2 = r0 + 1024;
+                    writePages[(r16+76)>>>12][((r16+76)>>>2)&0x3ff] = r2;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 1024;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x3d0b8:
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d1d4;
+                        continue;
+                    }
+                    r23 = r21 + r0;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d204;
+                        run_3d200(); return;
+                    }
+                case 0x3d0cc:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 4096;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d33c;
+                        run_3d200(); return;
+                    }
+                    r2 = readPages[(r16+80)>>>12][((r16+80)>>>2)&0x3ff];
+                case 0x3d0e4:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r5 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    r20 = r2 - r3;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d368;
+                        run_3d200(); return;
+                    }
+                    r6 = readPages[(r16+60)>>>12][((r16+60)>>>2)&0x3ff];
+                    r20 = r20 - r6;
+                case 0x3d104:
+                    r2 = readPages[(r16+56)>>>12][((r16+56)>>>2)&0x3ff];
+                    r4 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r20 = r20 + r3;
+                    r2 = r2 - r4;
+                    r20 = r20 - r2;
+                    r2 = r6 + r2;
+                case 0x3d11c:
+                    r3 = r23 < r20 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d220;
+                        run_3d200(); return;
+                    }
+                    r3 = r20 + r2;
+                    r3 = ((r23 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d220;
+                        run_3d200(); return;
+                    }
+                    r20 = r23 - r20;
+                    r4 = r4 + r20;
+                    r2 = r2 - r20;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r4;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d170;
+                        continue;
+                    }
+                    r2 = r16 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d16c;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3d16c;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x3d16c:
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                case 0x3d170:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 65503;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x3d180:
+                    r4 = r16 + 92;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    r31=0x3d194;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x3d194:
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3cea0;
+                    run_3ce00(); return;
+                case 0x3d1a0:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r20 = r20 - r2;
+                    r2 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d1c8;
+                        continue;
+                    }
+                    r2 = readPages[(r16+60)>>>12][((r16+60)>>>2)&0x3ff];
+                    r20 = r20 - r2;
+                case 0x3d1c8:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3d01c;
+                    continue;
+                case 0x3d1d4:
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    r4 = r17 + r0;
+                    r6 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x3d1e8;
+                    pc=0x48960;
+                    run_48800(); return;
+                case 0x3d1e8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cf24;
+                        run_3ce00(); return;
+                    }
+                    r23 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r23 = r21 + r23;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d0cc;
+                        continue;
+                    }
+                case 0x3d200:
+                    pc=0x3d200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3d200() throws ExecutionException { /* 0x3d200 - 0x3d400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3d200:
+                case 0x3d204:
+                    r5 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d368;
+                        continue;
+                    }
+                    r6 = readPages[(r16+60)>>>12][((r16+60)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3d104;
+                    run_3d000(); return;
+                case 0x3d220:
+                    r20 = readPages[(r16+76)>>>12][((r16+76)>>>2)&0x3ff];
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r20 = r0 - r20;
+                    r20 = r23 & r20;
+                    r4 = r17 + r0;
+                    r6 = r20 + r0;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r19;
+                    r31=0x3d244;
+                    return;
+                case 0x3d244:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cf24;
+                        run_3ce00(); return;
+                    }
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r5 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d284;
+                        continue;
+                    }
+                    r2 = r16 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d280;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3d280;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x3d280:
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                case 0x3d284:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r23 = r23 - r20;
+                    r2 = r2 & 65503;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r23 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d180;
+                        run_3d000(); return;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3d2ac;
+                    pc=0x41200;
+                    run_41200(); return;
+                case 0x3d2ac:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cf24;
+                        run_3ce00(); return;
+                    }
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r3 = ((r2 & 0xffffffffL) < (r23 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3cf24;
+                        run_3ce00(); return;
+                    }
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 - r23;
+                    r3 = r3 + r23;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d180;
+                    run_3d000(); return;
+                case 0x3d2e4:
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r6 = r0 + r0;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r19;
+                    r31=0x3d2fc;
+                    return;
+                case 0x3d2fc:
+                    r20 = r2 + r0;
+                    r2 = r0 + -1;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ce9c;
+                        run_3ce00(); return;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x3cfec;
+                    run_3ce00(); return;
+                case 0x3d318:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x3cf1c;
+                    run_3ce00(); return;
+                case 0x3d324:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3d334;
+                    pc=0x3e600;
+                    run_3e600(); return;
+                case 0x3d334:
+                    /* Next insn is delay slot */ 
+                    pc=0x3cee8;
+                    run_3ce00(); return;
+                case 0x3d33c:
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r6 = r0 + r0;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r19;
+                    r31=0x3d354;
+                    return;
+                case 0x3d354:
+                    r3 = r0 + -1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d0e4;
+                        run_3d000(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3cf24;
+                    run_3ce00(); return;
+                case 0x3d368:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r4 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r5 = r0 + r0;
+                    r2 = r2 - r4;
+                    r20 = r20 - r2;
+                    r2 = r3 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d11c;
+                    run_3d000(); return;
+                case 0x3d388:
+                    r2 = r0 + 29;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    r20 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3cea0;
+                    run_3ce00(); return;
+                case 0x3d400:
+                    pc=0x3d400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3d400() throws ExecutionException { /* 0x3d400 - 0x3d600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3d400:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ce00;
+                    run_3ce00(); return;
+                case 0x3d600:
+                    pc=0x3d600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3d600() throws ExecutionException { /* 0x3d600 - 0x3d800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3d600:
+                    r29 = r29 + -48;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r19 = r4 + 736;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r21;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d6cc;
+                        continue;
+                    }
+                    r21 = r5 + r0;
+                    r20 = r0 + r0;
+                    r18 = r0 + -1;
+                case 0x3d638:
+                    r17 = readPages[(r19+4)>>>12][((r19+4)>>>2)&0x3ff];
+                    r16 = readPages[(r19+8)>>>12][((r19+8)>>>2)&0x3ff];
+                    r17 = r17 + -1;
+                    if(r17 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d690;
+                        continue;
+                    }
+                case 0x3d64c:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r3 = (r3&0xffffffffL) < (2&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d680;
+                        continue;
+                    }
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d680;
+                        continue;
+                    }
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r21;
+                    r31=0x3d67c;
+                    return;
+                case 0x3d67c:
+                    r20 = r20 | r2;
+                case 0x3d680:
+                    r17 = r17 + -1;
+                    r16 = r16 + 104;
+                    if(r17 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d64c;
+                        continue;
+                    }
+                case 0x3d690:
+                    r19 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d638;
+                        continue;
+                    }
+                case 0x3d6a0:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r20 + r0;
+                    r21 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3d6cc:
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d6a0;
+                    continue;
+                case 0x3d800:
+                    pc=0x3d800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3d800() throws ExecutionException { /* 0x3d800 - 0x3da00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3d800:
+                    r29 = r29 + -48;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    r19 = r4 + 736;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r20 = r4 + r0;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d8dc;
+                        continue;
+                    }
+                    r21 = r5 + r0;
+                    r22 = r0 + r0;
+                    r18 = r0 + -1;
+                case 0x3d840:
+                    r17 = readPages[(r19+4)>>>12][((r19+4)>>>2)&0x3ff];
+                    r16 = readPages[(r19+8)>>>12][((r19+8)>>>2)&0x3ff];
+                    r17 = r17 + -1;
+                    if(r17 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d89c;
+                        continue;
+                    }
+                case 0x3d854:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r3 = (r3&0xffffffffL) < (2&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d88c;
+                        continue;
+                    }
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d88c;
+                        continue;
+                    }
+                    r4 = r20 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r21;
+                    r31=0x3d888;
+                    return;
+                case 0x3d888:
+                    r22 = r22 | r2;
+                case 0x3d88c:
+                    r17 = r17 + -1;
+                    r16 = r16 + 104;
+                    if(r17 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d854;
+                        continue;
+                    }
+                case 0x3d89c:
+                    r19 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3d840;
+                        continue;
+                    }
+                case 0x3d8ac:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r22 + r0;
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3d8dc:
+                    r22 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3d8ac;
+                    continue;
+                case 0x3da00:
+                    pc=0x3da00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3da00() throws ExecutionException { /* 0x3da00 - 0x3dc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3da00:
+                    { long hilo = (long)(r7) * ((long)r6); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r29 = r29 + -64;
+                    r2 = r29 + 28;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r18;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r20;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r19;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r17;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    r18 = lo;
+                    r19 = r6 + r0;
+                    r20 = r7 + r0;
+                    r16 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3da68;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3db14;
+                        continue;
+                    }
+                case 0x3da68:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r2 = r3 & 8192;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3da94;
+                        continue;
+                    }
+                    r3 = r3 | 8192;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff];
+                    r2 = r0 + -8193;
+                    r2 = r3 & r2;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r2;
+                case 0x3da94:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    r6 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x3daa8;
+                    pc=0x59c00;
+                    run_59c00(); return;
+                case 0x3daa8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3daec;
+                        continue;
+                    }
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r18 = r18 - r2;
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r19!=0) {
+                        hi = (int)((r18 & 0xffffffffL) % (r19 & 0xffffffffL)); lo = (int)((r18 & 0xffffffffL) / (r19 & 0xffffffffL));
+                        }
+                        pc=0x3dac8;
+                        continue;
+                    }
+                    if(r19!=0) {
+                    hi = (int)((r18 & 0xffffffffL) % (r19 & 0xffffffffL)); lo = (int)((r18 & 0xffffffffL) / (r19 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x3dac8:
+                    r20 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r19 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r18 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r17 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    r2 = lo;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3daec:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r2 = r20 + r0;
+                    r19 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r20 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r18 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r17 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3db14:
+                    /* Next insn is delay slot */ 
+                    r31=0x3db1c;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x3db1c:
+                    /* Next insn is delay slot */ 
+                    pc=0x3da68;
+                    continue;
+                case 0x3dc00:
+                    pc=0x3dc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3dc00() throws ExecutionException { /* 0x3dc00 - 0x3de00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3dc00:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r8 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x3dc30;
+                    pc=0x3da00;
+                    run_3da00(); return;
+                case 0x3dc30:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3de00:
+                    pc=0x3de00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3de00() throws ExecutionException { /* 0x3de00 - 0x3e000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3de00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3e200;
+                    run_3e200(); return;
+                case 0x3e000:
+                    pc=0x3e000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3e000() throws ExecutionException { /* 0x3e000 - 0x3e200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3e000:
+                    r29 = r29 + -32;
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r29 + 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e01c;
+                    pc=0x3e200;
+                    run_3e200(); return;
+                case 0x3e01c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3e200:
+                    pc=0x3e200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3e200() throws ExecutionException { /* 0x3e200 - 0x3e400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3e200:
+                    r29 = r29 + -48;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r20 = r4 + r0;
+                    r18 = r5 + r0;
+                    r21 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e238;
+                    pc=0x58e00;
+                    run_58e00(); return;
+                case 0x3e238:
+                    r16 = readPages[(r28+-31080)>>>12][((r28+-31080)>>>2)&0x3ff];
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e2f0;
+                        continue;
+                    }
+                    addr=r18+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e354;
+                        continue;
+                    }
+                    r5 = r0 + 61;
+                    r2 = r18 + r0;
+                    r4 = r0 + 61;
+                    if(r3 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e27c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3e2f0;
+                    continue;
+                case 0x3e274:
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e2f0;
+                        continue;
+                    }
+                case 0x3e27c:
+                    r2 = r2 + 1;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e274;
+                        continue;
+                    }
+                    r17 = r2 - r18;
+                case 0x3e294:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e2f0;
+                        continue;
+                    }
+                    r22 = r0 + 61;
+                case 0x3e2a8:
+                    r5 = r18 + r0;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e2b8;
+                    pc=0x43000;
+                    run_43000(); return;
+                case 0x3e2b8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e2dc;
+                        continue;
+                    }
+                    r19 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r19 = r19 + r17;
+                    addr=r19+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e32c;
+                        continue;
+                    }
+                case 0x3e2dc:
+                    r16 = r16 + 4;
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e2a8;
+                        continue;
+                    }
+                case 0x3e2f0:
+                    r4 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e2fc;
+                    pc=0x59000;
+                    run_59000(); return;
+                case 0x3e2fc:
+                    r2 = r0 + r0;
+                case 0x3e300:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3e32c:
+                    r2 = readPages[(r28+-31080)>>>12][((r28+-31080)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r16 = r16 - r2;
+                    r16 = r16 >> 2;
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e348;
+                    pc=0x59000;
+                    run_59000(); return;
+                case 0x3e348:
+                    r2 = r19 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3e300;
+                    continue;
+                case 0x3e354:
+                    r17 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3e294;
+                    continue;
+                case 0x3e400:
+                    pc=0x3e400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3e400() throws ExecutionException { /* 0x3e400 - 0x3e600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3e400:
+                    r29 = r29 + -32;
+                    r6 = r29 + 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e414;
+                    pc=0x3e200;
+                    run_3e200(); return;
+                case 0x3e414:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3e600:
+                    pc=0x3e600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3e600() throws ExecutionException { /* 0x3e600 - 0x3e800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3e600:
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -104;
+                    r3 = r2 & 65535;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r16;
+                    r16 = r5 + r0;
+                    r5 = r3 & 2;
+                    writePages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff] = r31;
+                    writePages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff] = r19;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r18;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r17;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e730;
+                        continue;
+                    }
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    r17 = r4 + r0;
+                    if(r5 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e6f0;
+                        continue;
+                    }
+                    r6 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e64c;
+                    pc=0x48960;
+                    run_48800(); return;
+                case 0x3e64c:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e6e4;
+                        continue;
+                    }
+                    r2 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = r0 | 32768;
+                    r2 = r2 & 61440;
+                    r19 = r2 ^ 8192;
+                    r19 = (r19&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e770;
+                        continue;
+                    }
+                case 0x3e670:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r18 = r0 + 1024;
+                    r2 = r2 | 2048;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x3e680:
+                    r4 = r17 + r0;
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e690;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x3e690:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e714;
+                        continue;
+                    }
+                    r3 = 4 << 16;
+                    r3 = r3 + -24576;
+                    writePages[(r17+60)>>>12][((r17+60)>>>2)&0x3ff] = r3;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r3 = r3 | 128;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r2;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r18;
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e7a4;
+                        continue;
+                    }
+                case 0x3e6c4:
+                    r31 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    r19 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r18 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r17 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r16 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r29 = r29 + 104;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3e6e4:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r3 = r2 & 65535;
+                case 0x3e6f0:
+                    r3 = r3 & 128;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e764;
+                        continue;
+                    }
+                    r18 = r0 + 1024;
+                case 0x3e700:
+                    r2 = r2 | 2048;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3e680;
+                    continue;
+                case 0x3e714:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r3 = r2 & 512;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e6c4;
+                        continue;
+                    }
+                    r2 = r2 | 2;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x3e730:
+                    r2 = r16 + 67;
+                    r31 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    r19 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r18 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r17 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r29 = r29 + 104;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3e764:
+                    r18 = r0 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=0x3e700;
+                    continue;
+                case 0x3e770:
+                    r2 = 4 << 16;
+                    r3 = readPages[(r16+40)>>>12][((r16+40)>>>2)&0x3ff];
+                    r2 = r2 + 10240;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e670;
+                        continue;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r18 = r0 + 1024;
+                    r2 = r2 | 1024;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 1024;
+                    writePages[(r16+76)>>>12][((r16+76)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x3e680;
+                    continue;
+                case 0x3e7a4:
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3e7b4;
+                    pc=0x56800;
+                    run_56800(); return;
+                case 0x3e7b4:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3e6c4;
+                        continue;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 1;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x3e6c4;
+                    continue;
+                case 0x3e800:
+                    pc=0x3e800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3e800() throws ExecutionException { /* 0x3e800 - 0x3ea00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3e800:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x3ea00:
+                    pc=0x3ea00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3ea00() throws ExecutionException { /* 0x3ea00 - 0x3ec00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3ea00:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x3ec00:
+                    pc=0x3ec00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3ec00() throws ExecutionException { /* 0x3ec00 - 0x3ee00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3ec00:
+                    r2 = r5 + 11;
+                    r29 = r29 + -64;
+                    r3 = (r2&0xffffffffL) < (23&0xffffffffL) ? 1 : 0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r30;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r23;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r22;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r21;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r19 = r4 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ed04;
+                        continue;
+                    }
+                    r17 = r0 + -8;
+                    r17 = r2 & r17;
+                    if(r17 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ed14;
+                        continue;
+                    }
+                    r5 = ((r17 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ed14;
+                        continue;
+                    }
+                case 0x3ec5c:
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3ec68;
+                    pc=0x3f600;
+                    run_3f600(); return;
+                case 0x3ec68:
+                    r2 = (r17&0xffffffffL) < (504&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ed28;
+                        continue;
+                    }
+                    r18 = 7 << 16;
+                    r18 = r18 + 11104;
+                    r2 = r18 + r17;
+                    r16 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r7 = r17 >>> 3;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f2d8;
+                        run_3f200(); return;
+                    }
+                case 0x3ec90:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r0 + -4;
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r3 & r2;
+                    r3 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = r3;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r4;
+                case 0x3ecb0:
+                    r2 = r16 + r2;
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r4 = r19 + r0;
+                    r3 = r3 | 1;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x3eccc;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3eccc:
+                    r2 = r16 + 8;
+                case 0x3ecd0:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3ed04:
+                    r17 = r0 + 16;
+                    r5 = ((r17 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ec5c;
+                        continue;
+                    }
+                case 0x3ed14:
+                    r2 = r0 + 12;
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ecd0;
+                    continue;
+                case 0x3ed28:
+                    r2 = r17 >>> 9;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ef4c;
+                        run_3ee00(); return;
+                    }
+                    r3 = (r2&0xffffffffL) < (5&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f1b8;
+                        run_3f000(); return;
+                    }
+                    r8 = r17 >>> 6;
+                    r8 = r8 + 56;
+                    r6 = r8 << 1;
+                case 0x3ed4c:
+                    r18 = 7 << 16;
+                    r6 = r6 << 2;
+                    r18 = r18 + 11104;
+                    r6 = r18 + r6;
+                    r16 = readPages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff];
+                    if(r6 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3edd0;
+                        continue;
+                    }
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r0 + -4;
+                    r3 = r3 & r2;
+                    r4 = r3 - r17;
+                    r2 = r4 < 16 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ef5c;
+                        run_3ee00(); return;
+                    }
+                    r7 = r0 + -4;
+                    if(r4 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3edc0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3ef68;
+                    run_3ee00(); return;
+                case 0x3ed9c:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r3 = r3 & r7;
+                    r2 = r3 - r17;
+                    r5 = r2 < 16 ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ef5c;
+                        run_3ee00(); return;
+                    }
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ef68;
+                        run_3ee00(); return;
+                    }
+                case 0x3edc0:
+                    r16 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    if(r6 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ed9c;
+                        continue;
+                    }
+                case 0x3edd0:
+                    r7 = r8 + 1;
+                case 0x3edd4:
+                    r9 = 7 << 16;
+                    r16 = readPages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff];
+                    r9 = r9 + 11112;
+                    if(r16 == r9) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f2b0;
+                        run_3f200(); return;
+                    }
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r0 + -4;
+                    r2 = r3 & r2;
+                    r3 = r2 - r17;
+                    r4 = r3 < 16 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f26c;
+                        run_3f200(); return;
+                    }
+                case 0x3ee00:
+                    pc=0x3ee00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3ee00() throws ExecutionException { /* 0x3ee00 - 0x3f000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3ee00:
+                    writePages[(r18+20)>>>12][((r18+20)>>>2)&0x3ff] = r9;
+                    writePages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff] = r9;
+                    if(r3 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ecb0;
+                        run_3ec00(); return;
+                    }
+                    r3 = (r2&0xffffffffL) < (512&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f1e4;
+                        run_3f000(); return;
+                    }
+                    r3 = r2 >>> 3;
+                    r2 = r3 >> 2;
+                    r4 = r0 + 1;
+                    r4 = r4 << (r2&0x1f);
+                    r3 = r3 << 3;
+                    r2 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    r3 = r18 + r3;
+                    r2 = r4 | r2;
+                    r4 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff] = r2;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r3;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r4;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r16;
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = r16;
+                case 0x3ee58:
+                    r3 = r7 >> 2;
+                    r4 = r0 + 1;
+                    r4 = r4 << (r3&0x1f);
+                    r3 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3efa0;
+                        continue;
+                    }
+                    r3 = r2 & r4;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ee98;
+                        continue;
+                    }
+                    r3 = r0 + -4;
+                    r7 = r7 & r3;
+                case 0x3ee84:
+                    r4 = r4 << 1;
+                    r3 = r2 & r4;
+                    r7 = r7 + 4;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ee84;
+                        continue;
+                    }
+                case 0x3ee98:
+                    r8 = r0 + -4;
+                case 0x3ee9c:
+                    r10 = r7 << 3;
+                    r10 = r18 + r10;
+                    r6 = r10 + r0;
+                    r11 = r7 + r0;
+                case 0x3eeac:
+                    r16 = readPages[(r6+12)>>>12][((r6+12)>>>2)&0x3ff];
+                    if(r6 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3eedc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3f2bc;
+                    run_3f200(); return;
+                case 0x3eec4:
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f2f4;
+                        run_3f200(); return;
+                    }
+                    r16 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    if(r6 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f2bc;
+                        run_3f200(); return;
+                    }
+                case 0x3eedc:
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r3 = r3 & r8;
+                    r2 = r3 - r17;
+                    r5 = r2 < 16 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3eec4;
+                        continue;
+                    }
+                    r4 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r5 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r3 = r16 + r17;
+                    r17 = r17 | 1;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r17;
+                    writePages[(r5+12)>>>12][((r5+12)>>>2)&0x3ff] = r4;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = r5;
+                    r4 = r2 | 1;
+                    writePages[(r18+20)>>>12][((r18+20)>>>2)&0x3ff] = r3;
+                    writePages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff] = r3;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r9;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r9;
+                    r3 = r3 + r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3ef40;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3ef40:
+                    r2 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ecd0;
+                    run_3ec00(); return;
+                case 0x3ef4c:
+                    r6 = r0 + 126;
+                    r8 = r0 + 63;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ed4c;
+                    run_3ec00(); return;
+                case 0x3ef5c:
+                    r8 = r8 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3edd0;
+                    run_3ec00(); return;
+                case 0x3ef68:
+                    r2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r4 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r3 = r16 + r3;
+                    writePages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff] = r2;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r4;
+                    r2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r19 + r0;
+                    r2 = r2 | 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x3ef94;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3ef94:
+                    r2 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ecd0;
+                    run_3ec00(); return;
+                case 0x3efa0:
+                    r16 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r2 = r0 + -4;
+                    r21 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r21 = r21 & r2;
+                    r2 = ((r21 & 0xffffffffL) < (r17 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3efd0;
+                        continue;
+                    }
+                    r2 = r21 - r17;
+                    r3 = r2 < 16 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f188;
+                        run_3f000(); return;
+                    }
+                case 0x3efd0:
+                    r22 = readPages[(r28+-30640)>>>12][((r28+-30640)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x3efdc;
+                    pc=0x48b80;
+                    run_48a00(); return;
+                case 0x3efdc:
+                    r3 = readPages[(r28+-31068)>>>12][((r28+-31068)>>>2)&0x3ff];
+                    r22 = r22 + 16;
+                    r23 = r2 + r0;
+                    r2 = r0 + -1;
+                    r30 = r16 + r21;
+                    r22 = r22 + r17;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f00c;
+                        run_3f000(); return;
+                    }
+                    r2 = r22 + -1;
+                case 0x3f000:
+                    pc=0x3f000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3f000() throws ExecutionException { /* 0x3f000 - 0x3f200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3f000:
+                    r2 = r2 + r23;
+                    r22 = r0 - r23;
+                    r22 = r22 & r2;
+                case 0x3f00c:
+                    r4 = r19 + r0;
+                    r5 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3f01c;
+                    pc=0x48920;
+                    run_48800(); return;
+                case 0x3f01c:
+                    r20 = r2 + r0;
+                    r2 = r0 + -1;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f158;
+                        continue;
+                    }
+                    r2 = ((r20 & 0xffffffffL) < (r30 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f354;
+                        run_3f200(); return;
+                    }
+                case 0x3f038:
+                    r3 = 7 << 16;
+                    r2 = readPages[(r3+17968)>>>12][((r3+17968)>>>2)&0x3ff];
+                    r4 = r23 + -1;
+                    r2 = r22 + r2;
+                    writePages[(r3+17968)>>>12][((r3+17968)>>>2)&0x3ff] = r2;
+                    if(r30 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f4ac;
+                        run_3f400(); return;
+                    }
+                case 0x3f054:
+                    r6 = readPages[(r28+-31068)>>>12][((r28+-31068)>>>2)&0x3ff];
+                    r5 = r0 + -1;
+                    if(r6 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f4d0;
+                        run_3f400(); return;
+                    }
+                    r30 = r20 - r30;
+                    r2 = r2 + r30;
+                    writePages[(r3+17968)>>>12][((r3+17968)>>>2)&0x3ff] = r2;
+                case 0x3f070:
+                    r2 = r20 & 7;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f410;
+                        run_3f400(); return;
+                    }
+                    r5 = r0 + 8;
+                    r2 = r5 - r2;
+                    r20 = r20 + r2;
+                case 0x3f088:
+                    r22 = r20 + r22;
+                    r2 = r2 + r23;
+                    r4 = r22 & r4;
+                    r22 = r2 - r4;
+                    r5 = r22 + r0;
+                    r4 = r19 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x3f0ac;
+                    pc=0x48920;
+                    run_48800(); return;
+                case 0x3f0ac:
+                    r4 = r0 + -1;
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f4fc;
+                        run_3f400(); return;
+                    }
+                    r2 = r2 - r20;
+                    r4 = r22 + r2;
+                    r4 = r4 | 1;
+                case 0x3f0c8:
+                    r2 = readPages[(r3+17968)>>>12][((r3+17968)>>>2)&0x3ff];
+                    writePages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff] = r20;
+                    r2 = r22 + r2;
+                    writePages[(r3+17968)>>>12][((r3+17968)>>>2)&0x3ff] = r2;
+                    writePages[(r20+4)>>>12][((r20+4)>>>2)&0x3ff] = r4;
+                    if(r16 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f128;
+                        continue;
+                    }
+                    r3 = (r21&0xffffffffL) < (16&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f444;
+                        run_3f400(); return;
+                    }
+                    r4 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r21 = r21 + -12;
+                    r3 = r0 + -8;
+                    r3 = r21 & r3;
+                    r4 = r4 & 1;
+                    r4 = r3 | r4;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r4;
+                    r5 = r0 + 5;
+                    r4 = r16 + r3;
+                    r3 = (r3&0xffffffffL) < (16&0xffffffffL) ? 1 : 0;
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r5;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = r5;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f4dc;
+                        run_3f400(); return;
+                    }
+                case 0x3f128:
+                    r3 = readPages[(r28+-30644)>>>12][((r28+-30644)>>>2)&0x3ff];
+                    r3 = ((r3 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f140;
+                        continue;
+                    }
+                    writePages[(r28+-30644)>>>12][((r28+-30644)>>>2)&0x3ff] = r2;
+                case 0x3f140:
+                    r3 = readPages[(r28+-30648)>>>12][((r28+-30648)>>>2)&0x3ff];
+                    r3 = ((r3 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f158;
+                        continue;
+                    }
+                    writePages[(r28+-30648)>>>12][((r28+-30648)>>>2)&0x3ff] = r2;
+                case 0x3f158:
+                    r16 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r2 = r0 + -4;
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r3 = r3 & r2;
+                case 0x3f16c:
+                    r2 = r3 - r17;
+                    r3 = ((r3 & 0xffffffffL) < (r17 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f3d8;
+                        run_3f200(); return;
+                    }
+                    r3 = r2 < 16 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f3d8;
+                        run_3f200(); return;
+                    }
+                case 0x3f188:
+                    r3 = r17 | 1;
+                    r2 = r2 | 1;
+                    r17 = r16 + r17;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r3;
+                    r4 = r19 + r0;
+                    writePages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff] = r17;
+                    writePages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x3f1ac;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3f1ac:
+                    r2 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ecd0;
+                    run_3ec00(); return;
+                case 0x3f1b8:
+                    r3 = (r2&0xffffffffL) < (21&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f330;
+                        run_3f200(); return;
+                    }
+                    r3 = (r2&0xffffffffL) < (85&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f3f0;
+                        run_3f200(); return;
+                    }
+                    r8 = r17 >>> 12;
+                    r8 = r8 + 110;
+                    r6 = r8 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ed4c;
+                    run_3ec00(); return;
+                case 0x3f1e4:
+                    r3 = r2 >>> 9;
+                    r4 = (r3&0xffffffffL) < (5&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f340;
+                        run_3f200(); return;
+                    }
+                    r4 = (r3&0xffffffffL) < (21&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f47c;
+                        run_3f400(); return;
+                    }
+                case 0x3f200:
+                    pc=0x3f200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3f200() throws ExecutionException { /* 0x3f200 - 0x3f400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3f200:
+                    r4 = r3 + 91;
+                    r5 = r4 << 1;
+                case 0x3f208:
+                    r5 = r5 << 2;
+                    r5 = r18 + r5;
+                    r3 = readPages[(r5+8)>>>12][((r5+8)>>>2)&0x3ff];
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f41c;
+                        run_3f400(); return;
+                    }
+                    r6 = r0 + -4;
+                case 0x3f224:
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r4 & r6;
+                    r4 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f24c;
+                        continue;
+                    }
+                    r3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    if(r5 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f224;
+                        continue;
+                    }
+                case 0x3f24c:
+                    r4 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r2 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                case 0x3f254:
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r4;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r3;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = r16;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ee58;
+                    run_3ee00(); return;
+                case 0x3f26c:
+                    r2 = r16 + r17;
+                    r4 = r3 | 1;
+                    r17 = r17 | 1;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r17;
+                    writePages[(r18+20)>>>12][((r18+20)>>>2)&0x3ff] = r2;
+                    writePages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff] = r2;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r4;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r9;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r9;
+                    r2 = r2 + r3;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3f2a4;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3f2a4:
+                    r2 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ecd0;
+                    run_3ec00(); return;
+                case 0x3f2b0:
+                    r2 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3ee58;
+                    run_3ee00(); return;
+                case 0x3f2bc:
+                    r11 = r11 + 1;
+                    r2 = r11 & 3;
+                    r6 = r6 + 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3eeac;
+                        run_3ee00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3f378;
+                    continue;
+                case 0x3f2d8:
+                    r2 = r16 + 8;
+                    r16 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r7 = r7 + 2;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3edd4;
+                        run_3ec00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3ec90;
+                    run_3ec00(); return;
+                case 0x3f2f4:
+                    r3 = r16 + r3;
+                    r2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r4 = r19 + r0;
+                    r2 = r2 | 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x3f324;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3f324:
+                    r2 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ecd0;
+                    run_3ec00(); return;
+                case 0x3f330:
+                    r8 = r2 + 91;
+                    r6 = r8 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ed4c;
+                    run_3ec00(); return;
+                case 0x3f340:
+                    r4 = r2 >>> 6;
+                    r4 = r4 + 56;
+                    r5 = r4 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f208;
+                    continue;
+                case 0x3f354:
+                    if(r16 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f158;
+                        run_3f000(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3f038;
+                    run_3f000(); return;
+                case 0x3f364:
+                    r2 = r10 + -8;
+                    r10 = readPages[(r10+0)>>>12][((r10+0)>>>2)&0x3ff];
+                    r7 = r7 + -1;
+                    if(r10 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f55c;
+                        run_3f400(); return;
+                    }
+                case 0x3f378:
+                    r2 = r7 & 3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f364;
+                        continue;
+                    }
+                    r2 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    r3 = ~(r0 | r4);
+                    r2 = r3 & r2;
+                    writePages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff] = r2;
+                case 0x3f394:
+                    r4 = r4 << 1;
+                    r3 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3efa0;
+                        run_3ee00(); return;
+                    }
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3efa0;
+                        run_3ee00(); return;
+                    }
+                    r3 = r2 & r4;
+                    r7 = r11 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3ee9c;
+                        run_3ee00(); return;
+                    }
+                case 0x3f3bc:
+                    r4 = r4 << 1;
+                    r3 = r2 & r4;
+                    r7 = r7 + 4;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f3bc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x3ee9c;
+                    run_3ee00(); return;
+                case 0x3f3d8:
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x3f3e4;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x3f3e4:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ecd0;
+                    run_3ec00(); return;
+                case 0x3f3f0:
+                    r3 = (r2&0xffffffffL) < (341&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f45c;
+                        run_3f400(); return;
+                    }
+                    r8 = r17 >>> 15;
+                case 0x3f400:
+                    pc=0x3f400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3f400() throws ExecutionException { /* 0x3f400 - 0x3f600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3f400:
+                    r8 = r8 + 119;
+                    r6 = r8 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ed4c;
+                    run_3ec00(); return;
+                case 0x3f410:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f088;
+                    run_3f000(); return;
+                case 0x3f41c:
+                    r2 = r0 + 1;
+                    r4 = r4 >> 2;
+                    r4 = r2 << (r4&0x1f);
+                    r2 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    r2 = r4 | r2;
+                    writePages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff] = r2;
+                    r4 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f254;
+                    run_3f200(); return;
+                case 0x3f444:
+                    r2 = r0 + 1;
+                    writePages[(r20+4)>>>12][((r20+4)>>>2)&0x3ff] = r2;
+                    r16 = r20 + r0;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f16c;
+                    run_3f000(); return;
+                case 0x3f45c:
+                    r2 = (r2&0xffffffffL) < (1365&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f49c;
+                        continue;
+                    }
+                    r8 = r17 >>> 18;
+                    r8 = r8 + 124;
+                    r6 = r8 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ed4c;
+                    run_3ec00(); return;
+                case 0x3f47c:
+                    r4 = (r3&0xffffffffL) < (85&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f50c;
+                        continue;
+                    }
+                    r4 = r2 >>> 12;
+                    r4 = r4 + 110;
+                    r5 = r4 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f208;
+                    run_3f200(); return;
+                case 0x3f49c:
+                    r6 = r0 + 252;
+                    r8 = r0 + 126;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ed4c;
+                    run_3ec00(); return;
+                case 0x3f4ac:
+                    r5 = r30 & r4;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f054;
+                        run_3f000(); return;
+                    }
+                    r3 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    r4 = r22 + r21;
+                    r4 = r4 | 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f128;
+                    run_3f000(); return;
+                case 0x3f4d0:
+                    writePages[(r28+-31068)>>>12][((r28+-31068)>>>2)&0x3ff] = r20;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f070;
+                    run_3f000(); return;
+                case 0x3f4dc:
+                    r4 = r19 + r0;
+                    r5 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    r31=0x3f4ec;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x3f4ec:
+                    r2 = 7 << 16;
+                    r2 = readPages[(r2+17968)>>>12][((r2+17968)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3f128;
+                    run_3f000(); return;
+                case 0x3f4fc:
+                    r4 = r0 + 1;
+                    r22 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f0c8;
+                    run_3f000(); return;
+                case 0x3f50c:
+                    r4 = (r3&0xffffffffL) < (341&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f52c;
+                        continue;
+                    }
+                    r4 = r2 >>> 15;
+                    r4 = r4 + 119;
+                    r5 = r4 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f208;
+                    run_3f200(); return;
+                case 0x3f52c:
+                    r3 = (r3&0xffffffffL) < (1365&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3f54c;
+                        continue;
+                    }
+                    r4 = r2 >>> 18;
+                    r4 = r4 + 124;
+                    r5 = r4 << 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f208;
+                    run_3f200(); return;
+                case 0x3f54c:
+                    r5 = r0 + 252;
+                    r4 = r0 + 126;
+                    /* Next insn is delay slot */ 
+                    pc=0x3f208;
+                    run_3f200(); return;
+                case 0x3f55c:
+                    r2 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3f394;
+                    run_3f200(); return;
+                case 0x3f600:
+                    pc=0x3f600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3f600() throws ExecutionException { /* 0x3f600 - 0x3f800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3f600:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3f800:
+                    pc=0x3f800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3f800() throws ExecutionException { /* 0x3f800 - 0x3fa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3f800:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3fa00:
+                    pc=0x3fa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3fa00() throws ExecutionException { /* 0x3fa00 - 0x3fc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3fa00:
+                    r29 = r29 + -32;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r6;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r7;
+                    r6 = r5 + r0;
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r7 = r29 + 40;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x3fa28;
+                    pc=0x45c00;
+                    run_45c00(); return;
+                case 0x3fa28:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3fc00:
+                    pc=0x3fc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3fc00() throws ExecutionException { /* 0x3fc00 - 0x3fe00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3fc00:
+                    r29 = r29 + -32;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r6;
+                    r6 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r7;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r5;
+                    r5 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                    r7 = r29 + 36;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x3fc30;
+                    pc=0x45c00;
+                    run_45c00(); return;
+                case 0x3fc30:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3fe00:
+                    pc=0x3fe00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_3fe00() throws ExecutionException { /* 0x3fe00 - 0x40000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x3fe00:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3fe28;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3fec8;
+                        continue;
+                    }
+                case 0x3fe28:
+                    r2 = readPages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3fe74;
+                        continue;
+                    }
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                case 0x3fe54:
+                    r3 = r2 + 1;
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r3;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x3fe74:
+                    r3 = readPages[(r6+24)>>>12][((r6+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3fee8;
+                        continue;
+                    }
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r3 = r0 + 10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x3fe54;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = r0 + 10;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x3fec8:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x3fed8;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x3fed8:
+                    r6 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x3fe28;
+                    continue;
+                case 0x3fee8:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x40000:
+                    pc=0x40000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_40000() throws ExecutionException { /* 0x40000 - 0x40200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x40000:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r5 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40034;
+                        continue;
+                    }
+                    r3 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x400cc;
+                        continue;
+                    }
+                case 0x40034:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40084;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                case 0x40060:
+                    r3 = r2 + 1;
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x40084:
+                    r3 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r2 = r2 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x400dc;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r0 + 10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r17&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40060;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r0 + 10;
+                    /* Next insn is delay slot */ 
+                    pc=0x400e4;
+                    continue;
+                case 0x400cc:
+                    /* Next insn is delay slot */ 
+                    r31=0x400d4;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x400d4:
+                    /* Next insn is delay slot */ 
+                    pc=0x40034;
+                    continue;
+                case 0x400dc:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r17 + r0;
+                case 0x400e4:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r6 = r16 + r0;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x40200:
+                    pc=0x40200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_40200() throws ExecutionException { /* 0x40200 - 0x40400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x40200:
+                    r29 = r29 + -64;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = r5 + r0;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    r16 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40224;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x40224:
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r2 = r2 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 16;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    r3 = r3 + -7636;
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 1;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r3;
+                    addr=r2+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r4 = r3 & 8192;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40288;
+                        continue;
+                    }
+                    r3 = r3 | 8192;
+                    r4 = readPages[(r2+100)>>>12][((r2+100)>>>2)&0x3ff];
+                    addr=r2+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + -8193;
+                    r3 = r4 & r3;
+                    writePages[(r2+100)>>>12][((r2+100)>>>2)&0x3ff] = r3;
+                case 0x40288:
+                    r5 = readPages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r6 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x4029c;
+                    pc=0x59c00;
+                    run_59c00(); return;
+                case 0x4029c:
+                    r3 = r0 + 10;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x402c4;
+                        continue;
+                    }
+                case 0x402a8:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r17 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r16 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = r3 + r0;
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x402c4:
+                    r3 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x402a8;
+                    continue;
+                case 0x40400:
+                    pc=0x40400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_40400() throws ExecutionException { /* 0x40400 - 0x40600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x40400:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x40200;
+                    run_40200(); return;
+                case 0x40600:
+                    pc=0x40600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_40600() throws ExecutionException { /* 0x40600 - 0x40800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x40600:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x40800;
+                    run_40800(); return;
+                case 0x40800:
+                    pc=0x40800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_40800() throws ExecutionException { /* 0x40800 - 0x40a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x40800:
+                    r29 = r29 + -56;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r23;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r16 = r5 + r0;
+                    r20 = r6 + r0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40b4c;
+                        run_40a00(); return;
+                    }
+                    r21 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40848;
+                    pc=0x3f600;
+                    run_3f600(); return;
+                case 0x40848:
+                    r3 = readPages[(r16+-4)>>>12][((r16+-4)>>>2)&0x3ff];
+                    r2 = r20 + 11;
+                    r17 = r0 + -4;
+                    r4 = (r2&0xffffffffL) < (23&0xffffffffL) ? 1 : 0;
+                    r19 = r16 + -8;
+                    r17 = r3 & r17;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4098c;
+                        continue;
+                    }
+                    r4 = r0 + 16;
+                    r18 = r0 + 16;
+                case 0x40870:
+                    r2 = ((r18 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x409a0;
+                        continue;
+                    }
+                    r2 = r17 < r4 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x409e0;
+                        continue;
+                    }
+                    r23 = 7 << 16;
+                    r23 = r23 + 11104;
+                    r5 = readPages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff];
+                    r2 = r19 + r17;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40b84;
+                        run_40a00(); return;
+                    }
+                    r6 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r7 = r0 + -2;
+                    r7 = r6 & r7;
+                    r7 = r2 + r7;
+                    r7 = readPages[(r7+4)>>>12][((r7+4)>>>2)&0x3ff];
+                    r7 = r7 & 1;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x409b4;
+                        continue;
+                    }
+                    r6 = r0 + r0;
+                    r2 = r0 + r0;
+                case 0x408cc:
+                    r3 = r3 & 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40aa4;
+                        run_40a00(); return;
+                    }
+                    r22 = readPages[(r16+-8)>>>12][((r16+-8)>>>2)&0x3ff];
+                    r3 = r0 + -4;
+                    r22 = r19 - r22;
+                    r7 = readPages[(r22+4)>>>12][((r22+4)>>>2)&0x3ff];
+                    r3 = r7 & r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40c98;
+                        run_40c00(); return;
+                    }
+                    r3 = r3 + r17;
+                    if(r2 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40ca4;
+                        run_40c00(); return;
+                    }
+                    r23 = r6 + r3;
+                    r5 = r23 < r4 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40a94;
+                        run_40a00(); return;
+                    }
+                    r3 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                case 0x40928:
+                    r2 = readPages[(r22+12)>>>12][((r22+12)>>>2)&0x3ff];
+                    r3 = readPages[(r22+8)>>>12][((r22+8)>>>2)&0x3ff];
+                    r6 = r17 + -4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                    r2 = (r6&0xffffffffL) < (37&0xffffffffL) ? 1 : 0;
+                    r19 = r22 + 8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40c70;
+                        run_40c00(); return;
+                    }
+                    r2 = (r6&0xffffffffL) < (20&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40be4;
+                        run_40a00(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r22+8)>>>12][((r22+8)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r22+12)>>>12][((r22+12)>>>2)&0x3ff] = r2;
+                    r2 = (r6&0xffffffffL) < (28&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40dc0;
+                        run_40c00(); return;
+                    }
+                    r3 = r22 + 16;
+                    r16 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x40be8;
+                    run_40a00(); return;
+                case 0x4098c:
+                    r18 = r0 + -8;
+                    r18 = r2 & r18;
+                    r4 = r18 + r0;
+                    if(r18 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40870;
+                        continue;
+                    }
+                case 0x409a0:
+                    r2 = r0 + 12;
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x40a20;
+                    run_40a00(); return;
+                case 0x409b4:
+                    r7 = r0 + -4;
+                    r6 = r6 & r7;
+                    r7 = r6 + r17;
+                    r8 = r7 < r4 ? 1 : 0;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x408cc;
+                        continue;
+                    }
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r2 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    r17 = r7 + r0;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r4;
+                    writePages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff] = r2;
+                case 0x409e0:
+                    r6 = r17 - r18;
+                    r2 = (r6&0xffffffffL) < (16&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40a54;
+                        run_40a00(); return;
+                    }
+                    r3 = r3 & 1;
+                    r3 = r3 | r17;
+                    writePages[(r19+4)>>>12][((r19+4)>>>2)&0x3ff] = r3;
+                    r17 = r19 + r17;
+                case 0x40a00:
+                    pc=0x40a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_40a00() throws ExecutionException { /* 0x40a00 - 0x40c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x40a00:
+                    r2 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r2 = r2 | 1;
+                    writePages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff] = r2;
+                case 0x40a10:
+                    r4 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40a1c;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x40a1c:
+                    r2 = r16 + r0;
+                case 0x40a20:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x40a54:
+                    r3 = r3 & 1;
+                    r5 = r19 + r18;
+                    r2 = r6 | 1;
+                    r18 = r3 | r18;
+                    writePages[(r19+4)>>>12][((r19+4)>>>2)&0x3ff] = r18;
+                    r6 = r5 + r6;
+                    writePages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r2 = r2 | 1;
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = r2;
+                    r5 = r5 + 8;
+                    /* Next insn is delay slot */ 
+                    r31=0x40a8c;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x40a8c:
+                    /* Next insn is delay slot */ 
+                    pc=0x40a10;
+                    continue;
+                case 0x40a94:
+                    r23 = r3 + r0;
+                case 0x40a98:
+                    r4 = r23 < r4 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40928;
+                        run_40800(); return;
+                    }
+                case 0x40aa4:
+                    r5 = r20 + r0;
+                    r4 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40ab4;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x40ab4:
+                    r20 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40e8c;
+                        run_40e00(); return;
+                    }
+                    r3 = readPages[(r16+-4)>>>12][((r16+-4)>>>2)&0x3ff];
+                    r4 = r2 + -8;
+                    r2 = r0 + -2;
+                    r2 = r3 & r2;
+                    r2 = r19 + r2;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40da8;
+                        run_40c00(); return;
+                    }
+                    r6 = r17 + -4;
+                    r2 = (r6&0xffffffffL) < (37&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40c58;
+                        run_40c00(); return;
+                    }
+                    r2 = (r6&0xffffffffL) < (20&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40bb0;
+                        continue;
+                    }
+                    r2 = r20 + r0;
+                    r3 = r16 + r0;
+                case 0x40b00:
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r4;
+                    r3 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                case 0x40b24:
+                    r4 = r21 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40b34;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x40b34:
+                    r4 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40b40;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x40b40:
+                    r2 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x40a20;
+                    continue;
+                case 0x40b4c:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r5 = r6 + r0;
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x40b84:
+                    r6 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    r2 = r0 + -4;
+                    r6 = r6 & r2;
+                    r2 = r6 + r17;
+                    r7 = r18 + 16;
+                    r7 = r2 < r7 ? 1 : 0;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40c1c;
+                        run_40c00(); return;
+                    }
+                    r2 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x408cc;
+                    run_40800(); return;
+                case 0x40bb0:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r20+4)>>>12][((r20+4)>>>2)&0x3ff] = r2;
+                    r2 = (r6&0xffffffffL) < (28&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40d74;
+                        run_40c00(); return;
+                    }
+                    r2 = r20 + 8;
+                    r3 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x40b00;
+                    continue;
+                case 0x40be4:
+                    r3 = r19 + r0;
+                case 0x40be8:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r17 = r23 + r0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r2;
+                case 0x40c00:
+                    pc=0x40c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_40c00() throws ExecutionException { /* 0x40c00 - 0x40e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x40c00:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r16 = r19 + r0;
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                    r3 = readPages[(r22+4)>>>12][((r22+4)>>>2)&0x3ff];
+                    r19 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x409e0;
+                    run_40800(); return;
+                case 0x40c1c:
+                    r2 = r2 - r18;
+                    r19 = r19 + r18;
+                    r2 = r2 | 1;
+                    writePages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff] = r19;
+                    writePages[(r19+4)>>>12][((r19+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+-4)>>>12][((r16+-4)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r2 = r2 & 1;
+                    r18 = r18 | r2;
+                    writePages[(r16+-4)>>>12][((r16+-4)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    r31=0x40c4c;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x40c4c:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x40a20;
+                    run_40a00(); return;
+                case 0x40c58:
+                    r4 = r20 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40c68;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x40c68:
+                    /* Next insn is delay slot */ 
+                    pc=0x40b24;
+                    run_40a00(); return;
+                case 0x40c70:
+                    r4 = r19 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40c80;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x40c80:
+                    r16 = r19 + r0;
+                    r3 = readPages[(r22+4)>>>12][((r22+4)>>>2)&0x3ff];
+                    r17 = r23 + r0;
+                    r19 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x409e0;
+                    run_40800(); return;
+                case 0x40c98:
+                    r23 = r3 + r17;
+                    /* Next insn is delay slot */ 
+                    pc=0x40a98;
+                    run_40a00(); return;
+                case 0x40ca4:
+                    r30 = r6 + r3;
+                    r2 = r18 + 16;
+                    r2 = r30 < r2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40a94;
+                        run_40a00(); return;
+                    }
+                    r2 = readPages[(r22+12)>>>12][((r22+12)>>>2)&0x3ff];
+                    r3 = readPages[(r22+8)>>>12][((r22+8)>>>2)&0x3ff];
+                    r6 = r17 + -4;
+                    writePages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff] = r2;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                    r2 = (r6&0xffffffffL) < (37&0xffffffffL) ? 1 : 0;
+                    r19 = r22 + 8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40e40;
+                        run_40e00(); return;
+                    }
+                    r2 = (r6&0xffffffffL) < (20&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40e34;
+                        run_40e00(); return;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r22+8)>>>12][((r22+8)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r22+12)>>>12][((r22+12)>>>2)&0x3ff] = r2;
+                    r2 = (r6&0xffffffffL) < (28&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40e58;
+                        run_40e00(); return;
+                    }
+                    r3 = r22 + 16;
+                    r16 = r16 + 8;
+                case 0x40d14:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    writePages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff] = r2;
+                case 0x40d38:
+                    r2 = r30 - r18;
+                    r3 = r22 + r18;
+                    r2 = r2 | 1;
+                    writePages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff] = r3;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r22+4)>>>12][((r22+4)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r2 = r2 & 1;
+                    r18 = r18 | r2;
+                    writePages[(r22+4)>>>12][((r22+4)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    r31=0x40d68;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x40d68:
+                    r2 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x40a20;
+                    run_40a00(); return;
+                case 0x40d74:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    writePages[(r20+8)>>>12][((r20+8)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    writePages[(r20+12)>>>12][((r20+12)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 36;
+                    if(r6 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40df4;
+                        continue;
+                    }
+                    r2 = r20 + 16;
+                    r3 = r16 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x40b00;
+                    run_40a00(); return;
+                case 0x40da8:
+                    r4 = readPages[(r20+-4)>>>12][((r20+-4)>>>2)&0x3ff];
+                    r2 = r0 + -4;
+                    r2 = r4 & r2;
+                    r17 = r17 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x409e0;
+                    run_40800(); return;
+                case 0x40dc0:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    writePages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    writePages[(r22+20)>>>12][((r22+20)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 36;
+                    if(r6 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40e14;
+                        run_40e00(); return;
+                    }
+                    r3 = r22 + 24;
+                    r16 = r16 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x40be8;
+                    run_40a00(); return;
+                case 0x40df4:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r3 = r16 + 24;
+                    writePages[(r20+16)>>>12][((r20+16)>>>2)&0x3ff] = r2;
+                case 0x40e00:
+                    pc=0x40e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_40e00() throws ExecutionException { /* 0x40e00 - 0x41000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x40e00:
+                    r4 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r2 = r20 + 24;
+                    writePages[(r20+20)>>>12][((r20+20)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x40b00;
+                    run_40a00(); return;
+                case 0x40e14:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r3 = r22 + 32;
+                    writePages[(r22+24)>>>12][((r22+24)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r16 = r16 + 24;
+                    writePages[(r22+28)>>>12][((r22+28)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x40be8;
+                    run_40a00(); return;
+                case 0x40e34:
+                    r3 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x40d14;
+                    run_40c00(); return;
+                case 0x40e40:
+                    r4 = r19 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40e50;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x40e50:
+                    /* Next insn is delay slot */ 
+                    pc=0x40d38;
+                    run_40c00(); return;
+                case 0x40e58:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    writePages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    writePages[(r22+20)>>>12][((r22+20)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 36;
+                    if(r6 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x40ea4;
+                        continue;
+                    }
+                    r3 = r22 + 24;
+                    r16 = r16 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x40d14;
+                    run_40c00(); return;
+                case 0x40e8c:
+                    r4 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x40e98;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x40e98:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x40a20;
+                    run_40a00(); return;
+                case 0x40ea4:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r3 = r22 + 32;
+                    writePages[(r22+24)>>>12][((r22+24)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r16 = r16 + 24;
+                    writePages[(r22+28)>>>12][((r22+28)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x40d14;
+                    run_40c00(); return;
+                case 0x41000:
+                    pc=0x41000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_41000() throws ExecutionException { /* 0x41000 - 0x41200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x41000:
+                    addr=r4+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r2 = r0 + 9;
+                    r3 = r3 & 9;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41020;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x41020:
+                    /* Next insn is delay slot */ 
+                    pc=0x39a00;
+                    run_39a00(); return;
+                case 0x41200:
+                    pc=0x41200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_41200() throws ExecutionException { /* 0x41200 - 0x41400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x41200:
+                    r29 = r29 + -40;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    r17 = r4 + r0;
+                    r16 = r5 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41238;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x413a0;
+                        continue;
+                    }
+                case 0x41238:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r2 = r3 & 65535;
+                    r4 = r2 & 8192;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4126c;
+                        continue;
+                    }
+                    r4 = readPages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff];
+                    r2 = r0 + -8193;
+                    r3 = r3 | 8192;
+                    r2 = r4 & r2;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r2;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r3 & 65535;
+                case 0x4126c:
+                    r4 = r2 & 32;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4137c;
+                        continue;
+                    }
+                    r4 = r2 & 4;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4133c;
+                        continue;
+                    }
+                    r5 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x412c4;
+                        continue;
+                    }
+                    r2 = r16 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x412b0;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x412b0;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x412b0:
+                    r2 = readPages[(r16+60)>>>12][((r16+60)>>>2)&0x3ff];
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4146c;
+                        run_41400(); return;
+                    }
+                case 0x412c4:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41498;
+                        run_41400(); return;
+                    }
+                case 0x412d4:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r19 = tmp;
+                    r18 = r19 & 65535;
+                    r2 = r18 & 3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x413b0;
+                        continue;
+                    }
+                case 0x412ec:
+                    r6 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r2 = readPages[(r16+32)>>>12][((r16+32)>>>2)&0x3ff];
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r7 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r6;
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x4130c;
+                    return;
+                case 0x4130c:
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41364;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                case 0x4131c:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4133c:
+                    r4 = r2 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x414b0;
+                        run_41400(); return;
+                    }
+                    r2 = r2 & 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4142c;
+                        run_41400(); return;
+                    }
+                    r3 = r3 | 4;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x412c4;
+                    continue;
+                case 0x41364:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x413f8;
+                        continue;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 32;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x4137c:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x413a0:
+                    /* Next insn is delay slot */ 
+                    r31=0x413a8;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x413a8:
+                    /* Next insn is delay slot */ 
+                    pc=0x41238;
+                    continue;
+                case 0x413b0:
+                    r2 = r0 + 1;
+                    r4 = readPages[(r28+-31076)>>>12][((r28+-31076)>>>2)&0x3ff];
+                    r5 = 4 << 16;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r5 = r5 + 4096;
+                    /* Next insn is delay slot */ 
+                    r31=0x413cc;
+                    pc=0x3d600;
+                    run_3d600(); return;
+                case 0x413cc:
+                    r18 = r18 & 9;
+                    r2 = r0 + 9;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r19&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x412ec;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x413f0;
+                    pc=0x39400;
+                    run_39400(); return;
+                case 0x413f0:
+                    /* Next insn is delay slot */ 
+                    pc=0x412ec;
+                    continue;
+                case 0x413f8:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                case 0x41400:
+                    pc=0x41400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_41400() throws ExecutionException { /* 0x41400 - 0x41600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x41400:
+                    r2 = r2 | 64;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    r2 = r0 + -1;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4142c:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x4143c;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x4143c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4137c;
+                        run_41200(); return;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    r3 = r3 & 65527;
+                    r3 = r3 << 16;
+                    r3 = r3 >> 16;
+                    r3 = r3 | 4;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x412c4;
+                    run_41200(); return;
+                case 0x4146c:
+                    r2 = readPages[(r16+56)>>>12][((r16+56)>>>2)&0x3ff];
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x41498:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x414a8;
+                    pc=0x3e600;
+                    run_3e600(); return;
+                case 0x414a8:
+                    /* Next insn is delay slot */ 
+                    pc=0x412d4;
+                    run_41200(); return;
+                case 0x414b0:
+                    r2 = r0 + 9;
+                    r3 = r3 | 64;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4131c;
+                    run_41200(); return;
+                case 0x41600:
+                    pc=0x41600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_41600() throws ExecutionException { /* 0x41600 - 0x41800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x41600:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    r16 = r5 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41630;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41684;
+                        continue;
+                    }
+                case 0x41630:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x41640;
+                    pc=0x41200;
+                    run_41200(); return;
+                case 0x41640:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41694;
+                        continue;
+                    }
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                case 0x4166c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x41684:
+                    /* Next insn is delay slot */ 
+                    r31=0x4168c;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x4168c:
+                    /* Next insn is delay slot */ 
+                    pc=0x41630;
+                    continue;
+                case 0x41694:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4166c;
+                    continue;
+                case 0x41800:
+                    pc=0x41800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_41800() throws ExecutionException { /* 0x41800 - 0x41a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x41800:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x41600;
+                    run_41600(); return;
+                case 0x41a00:
+                    pc=0x41a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_41a00() throws ExecutionException { /* 0x41a00 - 0x41c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x41a00:
+                    r29 = r29 + -144;
+                    writePages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff] = r17;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r16;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    r16 = r6 + r0;
+                    if(r6 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41af4;
+                        continue;
+                    }
+                    r2 = r0 + 520;
+                    addr=r29+28;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r5;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41aa4;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r29 + 160;
+                    r6 = r7 + r0;
+                    r4 = r17 + r0;
+                    r5 = r29 + 16;
+                    r7 = r2 + r0;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x41a6c;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x41a6c:
+                    r3 = r2 < -1 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41ae4;
+                        continue;
+                    }
+                case 0x41a78:
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41a8c;
+                        continue;
+                    }
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x41a8c:
+                    r31 = readPages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff];
+                    r17 = readPages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff];
+                    r16 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r29 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x41aa4:
+                    r2 = r6 + -1;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r29 + 160;
+                    r6 = r7 + r0;
+                    r4 = r17 + r0;
+                    r5 = r29 + 16;
+                    r7 = r2 + r0;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x41ad8;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x41ad8:
+                    r3 = r2 < -1 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41a78;
+                        continue;
+                    }
+                case 0x41ae4:
+                    r3 = r0 + 139;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x41a78;
+                    continue;
+                case 0x41af4:
+                    r2 = r0 + 139;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x41a8c;
+                    continue;
+                case 0x41c00:
+                    pc=0x41c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_41c00() throws ExecutionException { /* 0x41c00 - 0x41e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x41c00:
+                    r29 = r29 + -144;
+                    writePages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff] = r17;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r16;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r31;
+                    r16 = r5 + r0;
+                    writePages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff] = r7;
+                    r17 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    if(r5 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41ce8;
+                        continue;
+                    }
+                    r2 = r0 + 520;
+                    addr=r29+28;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r4;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41ca0;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r7 = r29 + 156;
+                    r2 = r0 + -1;
+                    r4 = r17 + r0;
+                    r5 = r29 + 16;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x41c68;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x41c68:
+                    r3 = r2 < -1 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41cd8;
+                        continue;
+                    }
+                case 0x41c74:
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41c88;
+                        continue;
+                    }
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x41c88:
+                    r31 = readPages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff];
+                    r17 = readPages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff];
+                    r16 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r29 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x41ca0:
+                    r2 = r5 + -1;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r7 = r29 + 156;
+                    r2 = r0 + -1;
+                    r4 = r17 + r0;
+                    r5 = r29 + 16;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x41ccc;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x41ccc:
+                    r3 = r2 < -1 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x41c74;
+                        continue;
+                    }
+                case 0x41cd8:
+                    r3 = r0 + 139;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x41c74;
+                    continue;
+                case 0x41ce8:
+                    r2 = r0 + 139;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x41c88;
+                    continue;
+                case 0x41e00:
+                    pc=0x41e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_41e00() throws ExecutionException { /* 0x41e00 - 0x42000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x41e00:
+                    r29 = r29 + -136;
+                    r2 = r0 + 520;
+                    addr=r29+28;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = 32767 << 16;
+                    r2 = r2 | 65535;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r7;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r5;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r7 = r29 + 148;
+                    r2 = r0 + -1;
+                    r5 = r29 + 16;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x41e48;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x41e48:
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42000:
+                    pc=0x42000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_42000() throws ExecutionException { /* 0x42000 - 0x42200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x42000:
+                    r29 = r29 + -136;
+                    r2 = r0 + 520;
+                    addr=r29+28;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = 32767 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r4;
+                    r2 = r2 | 65535;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r6;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r7;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r7 = r29 + 144;
+                    r6 = r5 + r0;
+                    r2 = r0 + -1;
+                    r5 = r29 + 16;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x42054;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x42054:
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42200:
+                    pc=0x42200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_42200() throws ExecutionException { /* 0x42200 - 0x42400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x42200:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r5 + r0;
+                    addr=r5+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4221c;
+                    pc=0x488a0;
+                    run_48800(); return;
+                case 0x4221c:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42244;
+                        continue;
+                    }
+                    r3 = readPages[(r16+80)>>>12][((r16+80)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = r3 + r2;
+                    writePages[(r16+80)>>>12][((r16+80)>>>2)&0x3ff] = r3;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42244:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = r3 & 61439;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42400:
+                    pc=0x42400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_42400() throws ExecutionException { /* 0x42400 - 0x42600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x42400:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42600:
+                    pc=0x42600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_42600() throws ExecutionException { /* 0x42600 - 0x42800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x42600:
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -40;
+                    r3 = r2 & 256;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    r19 = r4 + r0;
+                    r16 = r5 + r0;
+                    r18 = r6 + r0;
+                    r17 = r7 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42650;
+                        continue;
+                    }
+                    addr=r5+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    r6 = r0 + r0;
+                    r7 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    r31=0x4264c;
+                    pc=0x489a0;
+                    run_48800(); return;
+                case 0x4264c:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                case 0x42650:
+                    r3 = r0 + -4097;
+                    r2 = r2 & r3;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = r19 + r0;
+                    addr=r16+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r6 = r18 + r0;
+                    r7 = r17 + r0;
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x488e0;
+                    run_48800(); return;
+                case 0x42800:
+                    pc=0x42800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_42800() throws ExecutionException { /* 0x42800 - 0x42a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x42800:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r5 + r0;
+                    addr=r5+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4281c;
+                    pc=0x489a0;
+                    run_48800(); return;
+                case 0x4281c:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4284c;
+                        continue;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = r3 | 4096;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+80)>>>12][((r16+80)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4284c:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = r3 & 61439;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42a00:
+                    pc=0x42a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_42a00() throws ExecutionException { /* 0x42a00 - 0x42c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x42a00:
+                    addr=r5+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r5 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x48860;
+                    run_48800(); return;
+                case 0x42c00:
+                    pc=0x42c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_42c00() throws ExecutionException { /* 0x42c00 - 0x42e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x42c00:
+                    r2 = r4 | r5;
+                    r2 = r2 & 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42c68;
+                        continue;
+                    }
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x42c44;
+                    continue;
+                case 0x42c1c:
+                    addr=r4+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42c54;
+                        continue;
+                    }
+                    addr=r5+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r5 = r5 + 2;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42c8c;
+                        continue;
+                    }
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    if(r6 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42c8c;
+                        continue;
+                    }
+                case 0x42c44:
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r4 = r4 + 2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42c1c;
+                        continue;
+                    }
+                case 0x42c54:
+                    r2 = r3 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42c60:
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42c54;
+                        continue;
+                    }
+                case 0x42c68:
+                    r4 = r4 + 1;
+                    addr=r4+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r5 = r5 + 1;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42c60;
+                        continue;
+                    }
+                    r2 = r3 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42c8c:
+                    r2 = r6 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42e00:
+                    pc=0x42e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_42e00() throws ExecutionException { /* 0x42e00 - 0x43000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x42e00:
+                    r3 = r4 | r5;
+                    r3 = r3 & 3;
+                    r2 = r4 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42e90;
+                        continue;
+                    }
+                    r6 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r10 = 65278 << 16;
+                    r10 = r10 | 65279;
+                    r4 = ~(r0 | r6);
+                    r3 = r6 + r10;
+                    r9 = 32896 << 16;
+                    r3 = r4 & r3;
+                    r9 = r9 | 32896;
+                    r3 = r3 & r9;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42e90;
+                        continue;
+                    }
+                    r3 = r2 + r0;
+                case 0x42e44:
+                    r3 = r3 + 4;
+                    r5 = r5 + 4;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r6;
+                    r6 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r8 = ~(r0 | r6);
+                    r7 = r6 + r10;
+                    r7 = r8 & r7;
+                    r7 = r7 & r9;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42e44;
+                        continue;
+                    }
+                    r5 = r5 + 1;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r6 = tmp;
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42e94;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x42e90:
+                    r3 = r2 + r0;
+                case 0x42e94:
+                    r5 = r5 + 1;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r6 = tmp;
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x42e94;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x43000:
+                    pc=0x43000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_43000() throws ExecutionException { /* 0x43000 - 0x43200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x43000:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43098;
+                        continue;
+                    }
+                    r2 = r4 | r5;
+                    r2 = r2 & 3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x430a4;
+                        continue;
+                    }
+                case 0x43018:
+                    r6 = r6 + -1;
+                case 0x4301c:
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43158;
+                        continue;
+                    }
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43098;
+                        continue;
+                    }
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43098;
+                        continue;
+                    }
+                    r2 = r4 + 1;
+                    r5 = r5 + 1;
+                    r4 = r4 + r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x4306c;
+                    continue;
+                case 0x43054:
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43098;
+                        continue;
+                    }
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43098;
+                        continue;
+                    }
+                    r2 = r2 + 1;
+                    r5 = r5 + 1;
+                case 0x4306c:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r6 = tmp;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43054;
+                        continue;
+                    }
+                case 0x43080:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r3 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x43098:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x430a4:
+                    r2 = (r6&0xffffffffL) < (4&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43018;
+                        continue;
+                    }
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43018;
+                        continue;
+                    }
+                    r2 = r6 + -4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43098;
+                        continue;
+                    }
+                    r8 = 65278 << 16;
+                    r8 = r8 | 65279;
+                    r6 = r3 + r8;
+                    r7 = 32896 << 16;
+                    r3 = ~(r0 | r3);
+                    r3 = r6 & r3;
+                    r7 = r7 | 32896;
+                    r3 = r3 & r7;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43138;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x43098;
+                    continue;
+                case 0x43100:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r6 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    if(r3 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43164;
+                        continue;
+                    }
+                    r2 = r2 + -4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43098;
+                        continue;
+                    }
+                    r6 = r3 + r8;
+                    r3 = ~(r0 | r3);
+                    r3 = r6 & r3;
+                    r3 = r3 & r7;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43098;
+                        continue;
+                    }
+                case 0x43138:
+                    r3 = (r2&0xffffffffL) < (4&0xffffffffL) ? 1 : 0;
+                    r4 = r4 + 4;
+                    r5 = r5 + 4;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43100;
+                        continue;
+                    }
+                    r6 = r2 + -1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4301c;
+                        continue;
+                    }
+                case 0x43158:
+                    r2 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43080;
+                    continue;
+                case 0x43164:
+                    r6 = r2 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4301c;
+                    continue;
+                case 0x43200:
+                    pc=0x43200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_43200() throws ExecutionException { /* 0x43200 - 0x43400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x43200:
+                    r29 = r29 + -8;
+                    r11 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r2 = r5 + r0;
+                    writePages[(r29+4)>>>12][((r29+4)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x4321c;
+                    continue;
+                case 0x43218:
+                    r2 = r3 + r0;
+                case 0x4321c:
+                    r3 = r2 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r9 = r11 + r8;
+                    addr=r9+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r9 = tmp;
+                    r9 = r9 & 8;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43218;
+                        continue;
+                    }
+                    r9 = r0 + 45;
+                    if(r8 == r9) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43418;
+                        run_43400(); return;
+                    }
+                    r9 = r0 + 43;
+                    if(r8 == r9) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4342c;
+                        run_43400(); return;
+                    }
+                    r25 = r0 + r0;
+                case 0x4325c:
+                    r2 = r0 + -17;
+                    r2 = r7 & r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4339c;
+                        continue;
+                    }
+                    r2 = r0 + 48;
+                    if(r8 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43380;
+                        continue;
+                    }
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4339c;
+                        continue;
+                    }
+                    r24 = r0 + 10;
+                    r7 = r0 + 10;
+                case 0x43288:
+                    if(r25 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x433a8;
+                        continue;
+                    }
+                case 0x43290:
+                    r13 = 32768 << 16;
+                case 0x43294:
+                    if(r24 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r24!=0) {
+                        hi = (int)((r13 & 0xffffffffL) % (r24 & 0xffffffffL)); lo = (int)((r13 & 0xffffffffL) / (r24 & 0xffffffffL));
+                        }
+                        pc=0x432a0;
+                        continue;
+                    }
+                    if(r24!=0) {
+                    hi = (int)((r13 & 0xffffffffL) % (r24 & 0xffffffffL)); lo = (int)((r13 & 0xffffffffL) / (r24 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x432a0:
+                    r12 = r0 + r0;
+                    r2 = r0 + r0;
+                    r15 = r0 + 1;
+                    r14 = r0 + -1;
+                    r16 = hi;
+                    r13 = lo;
+                    /* Next insn is delay slot */ 
+                    pc=0x43308;
+                    continue;
+                case 0x432c0:
+                    r8 = r8 + -48;
+                    r9 = r8 < r7 ? 1 : 0;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43348;
+                        continue;
+                    }
+                case 0x432d0:
+                    if(r12 == r14) {
+                        /* Next insn is delay slot */ 
+                        pc=0x432fc;
+                        continue;
+                    }
+                    r9 = ((r13 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x433c4;
+                        continue;
+                    }
+                    if(r2 == r13) {
+                        /* Next insn is delay slot */ 
+                        pc=0x433b8;
+                        continue;
+                    }
+                case 0x432ec:
+                    { long hilo = (long)(r2) * ((long)r24); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r12 = r0 + 1;
+                    r2 = lo;
+                    r2 = r8 + r2;
+                case 0x432fc:
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                case 0x43308:
+                    r9 = r11 + r8;
+                    addr=r9+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r9 = tmp;
+                    r10 = r9 & 4;
+                    if(r10 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x432c0;
+                        continue;
+                    }
+                    r9 = r9 & 3;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43348;
+                        continue;
+                    }
+                    if(r9 == r15) {
+                        /* Next insn is delay slot */ 
+                        pc=0x433d0;
+                        continue;
+                    }
+                    r9 = r0 + 87;
+                    r8 = r8 - r9;
+                case 0x4333c:
+                    r9 = r8 < r7 ? 1 : 0;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x432d0;
+                        continue;
+                    }
+                case 0x43348:
+                    r7 = r0 + -1;
+                    if(r12 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x433e0;
+                        continue;
+                    }
+                    if(r25 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4340c;
+                        run_43400(); return;
+                    }
+                case 0x4335c:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43370;
+                        continue;
+                    }
+                    if(r12 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43400;
+                        run_43400(); return;
+                    }
+                case 0x4336c:
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r5;
+                case 0x43370:
+                    r16 = readPages[(r29+4)>>>12][((r29+4)>>>2)&0x3ff];
+                    r29 = r29 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x43380:
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r9 = tmp;
+                    r2 = r0 + 88;
+                    r9 = r9 & 223;
+                    if(r9 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4344c;
+                        run_43400(); return;
+                    }
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43464;
+                        run_43400(); return;
+                    }
+                case 0x4339c:
+                    r24 = r7 + r0;
+                    if(r25 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43290;
+                        continue;
+                    }
+                case 0x433a8:
+                    r13 = 32767 << 16;
+                    r13 = r13 | 65535;
+                    /* Next insn is delay slot */ 
+                    pc=0x43294;
+                    continue;
+                case 0x433b8:
+                    r9 = r16 < r8 ? 1 : 0;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x432ec;
+                        continue;
+                    }
+                case 0x433c4:
+                    r12 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x432fc;
+                    continue;
+                case 0x433d0:
+                    r9 = r0 + 55;
+                    r8 = r8 - r9;
+                    /* Next insn is delay slot */ 
+                    pc=0x4333c;
+                    continue;
+                case 0x433e0:
+                    if(r25 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43440;
+                        run_43400(); return;
+                    }
+                    r2 = 32767 << 16;
+                    r2 = r2 | 65535;
+                case 0x433f0:
+                    r5 = r0 + 34;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43370;
+                        continue;
+                    }
+                case 0x43400:
+                    pc=0x43400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_43400() throws ExecutionException { /* 0x43400 - 0x43600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x43400:
+                    r5 = r3 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4336c;
+                    run_43200(); return;
+                case 0x4340c:
+                    r2 = r0 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x4335c;
+                    run_43200(); return;
+                case 0x43418:
+                    r3 = r2 + 2;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r25 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4325c;
+                    run_43200(); return;
+                case 0x4342c:
+                    r3 = r2 + 2;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r25 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4325c;
+                    run_43200(); return;
+                case 0x43440:
+                    r2 = 32768 << 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x433f0;
+                    run_43200(); return;
+                case 0x4344c:
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r24 = r0 + 16;
+                    r3 = r3 + 2;
+                    r7 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x43288;
+                    run_43200(); return;
+                case 0x43464:
+                    r24 = r0 + 8;
+                    r7 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x43288;
+                    run_43200(); return;
+                case 0x43600:
+                    pc=0x43600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_43600() throws ExecutionException { /* 0x43600 - 0x43800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x43600:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43200;
+                    run_43200(); return;
+                case 0x43800:
+                    pc=0x43800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_43800() throws ExecutionException { /* 0x43800 - 0x43a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x43800:
+                    r29 = r29 + -304;
+                    writePages[(r29+300)>>>12][((r29+300)>>>2)&0x3ff] = r31;
+                    writePages[(r29+288)>>>12][((r29+288)>>>2)&0x3ff] = r22;
+                    writePages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff] = r4;
+                    r22 = r5 + r0;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r6;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r7;
+                    writePages[(r29+296)>>>12][((r29+296)>>>2)&0x3ff] = r30;
+                    writePages[(r29+292)>>>12][((r29+292)>>>2)&0x3ff] = r23;
+                    writePages[(r29+284)>>>12][((r29+284)>>>2)&0x3ff] = r21;
+                    writePages[(r29+280)>>>12][((r29+280)>>>2)&0x3ff] = r20;
+                    writePages[(r29+276)>>>12][((r29+276)>>>2)&0x3ff] = r19;
+                    writePages[(r29+272)>>>12][((r29+272)>>>2)&0x3ff] = r18;
+                    writePages[(r29+268)>>>12][((r29+268)>>>2)&0x3ff] = r17;
+                    writePages[(r29+264)>>>12][((r29+264)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x43844;
+                    pc=0x5ae00;
+                    run_5ae00(); return;
+                case 0x43844:
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    writePages[(r29+216)>>>12][((r29+216)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x4385c;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x4385c:
+                    writePages[(r29+232)>>>12][((r29+232)>>>2)&0x3ff] = r2;
+                    addr=r22+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 128;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43884;
+                        continue;
+                    }
+                    r2 = readPages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45464;
+                        run_45400(); return;
+                    }
+                case 0x43884:
+                    r21 = r29 + 40;
+                    r2 = 7 << 16;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r21;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r0;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r0;
+                    writePages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff] = r0;
+                    writePages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff] = r0;
+                    writePages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff] = r0;
+                    writePages[(r29+240)>>>12][((r29+240)>>>2)&0x3ff] = r0;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r0;
+                    writePages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff] = r0;
+                    r8 = r21 + r0;
+                    r19 = r2 + 652;
+                case 0x438b8:
+                    r3 = readPages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43fa4;
+                        run_43e00(); return;
+                    }
+                case 0x438d0:
+                    r3 = r0 + 37;
+                    r16 = readPages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff];
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x438f0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x4395c;
+                    continue;
+                case 0x438e8:
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43904;
+                        continue;
+                    }
+                case 0x438f0:
+                    r16 = r16 + 1;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x438e8;
+                        continue;
+                    }
+                case 0x43904:
+                    r3 = readPages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff];
+                    r17 = r16 - r3;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4395c;
+                        continue;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff];
+                    r2 = r2 + r17;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r2 = r2 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r2;
+                    r2 = r2 < 8 ? 1 : 0;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r17;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a04;
+                        run_43a00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x4394c:
+                    r3 = readPages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff];
+                    r3 = r3 + r17;
+                    writePages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff] = r3;
+                case 0x4395c:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a2c;
+                        run_43a00(); return;
+                    }
+                    r16 = r16 + 1;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r5 = r0 + r0;
+                    r30 = r0 + -1;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r0;
+                    r17 = r0 + r0;
+                    r6 = r0 + 42;
+                    r7 = r0 + r0;
+                case 0x4398c:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r3 = r16 + 1;
+                case 0x43994:
+                    r2 = r18 + -32;
+                    r4 = (r2&0xffffffffL) < (89&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4452c;
+                        run_44400(); return;
+                    }
+                    r4 = 7 << 16;
+                    r2 = r2 << 2;
+                    r4 = r4 + 280;
+                    r2 = r4 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x439c4:
+                    r17 = r17 | 16;
+                case 0x439c8:
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    continue;
+                case 0x439d4:
+                    r4 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r7 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r4 + 4;
+                    if(r7 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4451c;
+                        run_44400(); return;
+                    }
+                    r7 = r0 - r7;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r2;
+                case 0x439f4:
+                    r17 = r17 | 4;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    continue;
+                case 0x43a00:
+                    pc=0x43a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_43a00() throws ExecutionException { /* 0x43a00 - 0x43c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x43a00:
+                case 0x43a04:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x43a18;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x43a18:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        continue;
+                    }
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4394c;
+                    run_43800(); return;
+                case 0x43a2c:
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        continue;
+                    }
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x43a50;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x43a50:
+                    addr=r22+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a9c;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                case 0x43a68:
+                    r31 = readPages[(r29+300)>>>12][((r29+300)>>>2)&0x3ff];
+                    r30 = readPages[(r29+296)>>>12][((r29+296)>>>2)&0x3ff];
+                    r23 = readPages[(r29+292)>>>12][((r29+292)>>>2)&0x3ff];
+                    r22 = readPages[(r29+288)>>>12][((r29+288)>>>2)&0x3ff];
+                    r21 = readPages[(r29+284)>>>12][((r29+284)>>>2)&0x3ff];
+                    r20 = readPages[(r29+280)>>>12][((r29+280)>>>2)&0x3ff];
+                    r19 = readPages[(r29+276)>>>12][((r29+276)>>>2)&0x3ff];
+                    r18 = readPages[(r29+272)>>>12][((r29+272)>>>2)&0x3ff];
+                    r17 = readPages[(r29+268)>>>12][((r29+268)>>>2)&0x3ff];
+                    r16 = readPages[(r29+264)>>>12][((r29+264)>>>2)&0x3ff];
+                    r29 = r29 + 304;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x43a9c:
+                    r2 = readPages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x43a68;
+                    continue;
+                case 0x43aa8:
+                    r5 = r0 + 43;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    run_43800(); return;
+                case 0x43ab8:
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    r16 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r20 = r3 + 4;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4560c;
+                        run_45600(); return;
+                    }
+                    r4 = r16 + r0;
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x454e0;
+                        run_45400(); return;
+                    }
+                    r5 = r0 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x43af8;
+                    pc=0x5b400;
+                    run_5b400(); return;
+                case 0x43af8:
+                    r8 = readPages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x458ac;
+                        run_45800(); return;
+                    }
+                    r2 = r2 - r16;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r2;
+                    r2 = r30 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43b1c;
+                        continue;
+                    }
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r30;
+                case 0x43b1c:
+                    r2 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x454fc;
+                        run_45400(); return;
+                    }
+                case 0x43b2c:
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r2;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r20;
+                    r30 = r0 + r0;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                case 0x43b40:
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43b58;
+                        continue;
+                    }
+                case 0x43b48:
+                    r2 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r2;
+                case 0x43b58:
+                    r4 = r17 & 2;
+                    writePages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff] = r4;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43b78;
+                        continue;
+                    }
+                    r5 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    r5 = r5 + 2;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r5;
+                case 0x43b78:
+                    r2 = r17 & 132;
+                    writePages[(r29+204)>>>12][((r29+204)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44550;
+                        run_44400(); return;
+                    }
+                    r4 = readPages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff];
+                    r5 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    r20 = r4 - r5;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44550;
+                        run_44400(); return;
+                    }
+                    r2 = r20 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45548;
+                        run_45400(); return;
+                    }
+                    r4 = r20 + r0;
+                    writePages[(r29+244)>>>12][((r29+244)>>>2)&0x3ff] = r16;
+                    r20 = r17 + r0;
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    writePages[(r29+220)>>>12][((r29+220)>>>2)&0x3ff] = r19;
+                    r23 = r0 + 16;
+                    r16 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r17 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43bec;
+                    continue;
+                case 0x43bd8:
+                    r17 = r17 + -16;
+                    r4 = r17 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43c48;
+                        run_43c00(); return;
+                    }
+                case 0x43bec:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r19;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r23;
+                case 0x43c00:
+                    pc=0x43c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_43c00() throws ExecutionException { /* 0x43c00 - 0x43e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x43c00:
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43bd8;
+                        run_43a00(); return;
+                    }
+                    r4 = r16 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x43c24;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x43c24:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r17 = r17 + -16;
+                    r4 = r17 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43bec;
+                        run_43a00(); return;
+                    }
+                case 0x43c48:
+                    r4 = r17 + r0;
+                    r16 = readPages[(r29+244)>>>12][((r29+244)>>>2)&0x3ff];
+                    r17 = r20 + r0;
+                    r20 = r4 + r0;
+                case 0x43c58:
+                    r3 = r3 + 1;
+                    r4 = readPages[(r29+220)>>>12][((r29+220)>>>2)&0x3ff];
+                    r2 = r20 + r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r4;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44c1c;
+                        run_44c00(); return;
+                    }
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r8 = r8 + 8;
+                case 0x43c88:
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43cc4;
+                        continue;
+                    }
+                    r3 = r29 + 182;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 1;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r3 = r3 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44a50;
+                        run_44a00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x43cc4:
+                    r3 = readPages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43d08;
+                        continue;
+                    }
+                    r3 = r29 + 180;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 2;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r2 = r2 + 2;
+                    r3 = r3 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44a7c;
+                        run_44a00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x43d08:
+                    r4 = readPages[(r29+204)>>>12][((r29+204)>>>2)&0x3ff];
+                    r3 = r0 + 128;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x448bc;
+                        run_44800(); return;
+                    }
+                case 0x43d18:
+                    r3 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                    r20 = r30 - r3;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43e14;
+                        run_43e00(); return;
+                    }
+                    r3 = r20 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x450c0;
+                        run_45000(); return;
+                    }
+                    r5 = 7 << 16;
+                    r23 = r5 + 636;
+                    r4 = r23 + r0;
+                    writePages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff] = r16;
+                    r23 = r20 + r0;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r20 = r17 + r0;
+                    r30 = r0 + 16;
+                    r16 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r17 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43d7c;
+                    continue;
+                case 0x43d68:
+                    r23 = r23 + -16;
+                    r4 = r23 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43dd8;
+                        continue;
+                    }
+                case 0x43d7c:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r17;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r30;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43d68;
+                        continue;
+                    }
+                    r4 = r16 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x43db4;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x43db4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r23 = r23 + -16;
+                    r4 = r23 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43d7c;
+                        continue;
+                    }
+                case 0x43dd8:
+                    r4 = r17 + r0;
+                    r16 = readPages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff];
+                    r17 = r20 + r0;
+                    r20 = r23 + r0;
+                    r23 = r4 + r0;
+                case 0x43dec:
+                    r3 = r3 + 1;
+                    r2 = r2 + r20;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                case 0x43e00:
+                    pc=0x43e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_43e00() throws ExecutionException { /* 0x43e00 - 0x44000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x43e00:
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44a24;
+                        run_44a00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x43e14:
+                    r3 = r17 & 256;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44750;
+                        run_44600(); return;
+                    }
+                    r3 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    r2 = r2 + r3;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    r3 = r3 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44654;
+                        run_44600(); return;
+                    }
+                case 0x43e4c:
+                    r8 = r8 + 8;
+                case 0x43e50:
+                    r17 = r17 & 4;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43f50;
+                        continue;
+                    }
+                    r3 = readPages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff];
+                    r4 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    r16 = r3 - r4;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43f50;
+                        continue;
+                    }
+                    r3 = r16 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x455fc;
+                        run_45400(); return;
+                    }
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    writePages[(r29+220)>>>12][((r29+220)>>>2)&0x3ff] = r19;
+                    r17 = r0 + 16;
+                    r18 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x43eac;
+                    continue;
+                case 0x43e98:
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43f08;
+                        continue;
+                    }
+                case 0x43eac:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r19;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r17;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43e98;
+                        continue;
+                    }
+                    r4 = r18 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x43ee4;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x43ee4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43eac;
+                        continue;
+                    }
+                case 0x43f08:
+                    r3 = r3 + 1;
+                    r5 = readPages[(r29+220)>>>12][((r29+220)>>>2)&0x3ff];
+                    r2 = r2 + r16;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r5;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r16;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43f50;
+                        continue;
+                    }
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x43f44;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x43f44:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                case 0x43f50:
+                    r3 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    r5 = readPages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff];
+                    r4 = r3 < r5 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43f6c;
+                        continue;
+                    }
+                    r3 = r5 + r0;
+                case 0x43f6c:
+                    r4 = readPages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff];
+                    r4 = r4 + r3;
+                    writePages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff] = r4;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44680;
+                        run_44600(); return;
+                    }
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r0;
+                    r8 = r21 + r0;
+                case 0x43f8c:
+                    r3 = readPages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x438d0;
+                        run_43800(); return;
+                    }
+                case 0x43fa4:
+                    r16 = readPages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x4395c;
+                    run_43800(); return;
+                case 0x43fb0:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x439c8;
+                        run_43800(); return;
+                    }
+                    r5 = r0 + 32;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    run_43800(); return;
+                case 0x43fc8:
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r4 = r3 + 1;
+                    if(r18 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45b04;
+                        run_45a00(); return;
+                    }
+                    r2 = r18 + -48;
+                    r3 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    r30 = r0 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4401c;
+                        run_44000(); return;
+                    }
+                case 0x43fec:
+                    r4 = r4 + 1;
+                    r3 = r30 << 1;
+                    addr=r4+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r30 = r30 << 3;
+                    r30 = r3 + r30;
+                case 0x44000:
+                    pc=0x44000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_44000() throws ExecutionException { /* 0x44000 - 0x44200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x44000:
+                    r30 = r2 + r30;
+                    r2 = r18 + -48;
+                    r3 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43fec;
+                        run_43e00(); return;
+                    }
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45454;
+                        run_45400(); return;
+                    }
+                case 0x4401c:
+                    r3 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43994;
+                    run_43800(); return;
+                case 0x44028:
+                    r17 = r17 | 128;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    run_43800(); return;
+                case 0x44038:
+                    r7 = r0 + r0;
+                    r2 = r18 + -48;
+                case 0x44040:
+                    r3 = r3 + 1;
+                    r4 = r7 << 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r7 = r7 << 3;
+                    r7 = r4 + r7;
+                    r7 = r7 + r2;
+                    r2 = r18 + -48;
+                    r4 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44040;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x43994;
+                    run_43800(); return;
+                case 0x44070:
+                    r17 = r17 | 16;
+                    r2 = r17 & 16;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x444ec;
+                        run_44400(); return;
+                    }
+                case 0x44088:
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                case 0x440a4:
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x440b4;
+                        continue;
+                    }
+                    r5 = r0 + -129;
+                    r17 = r17 & r5;
+                case 0x440b4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x446ac;
+                        run_44600(); return;
+                    }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x446ac;
+                        run_44600(); return;
+                    }
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44ad0;
+                        run_44a00(); return;
+                    }
+                    r2 = r17 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44ad0;
+                        run_44a00(); return;
+                    }
+                    r2 = r0 + 48;
+                    addr=r29+143;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 1;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r2;
+                    r16 = r29 + 143;
+                case 0x440ec:
+                    r2 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                    r4 = r2 < r30 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44104;
+                        continue;
+                    }
+                    r2 = r30 + r0;
+                case 0x44104:
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r2;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b40;
+                    run_43a00(); return;
+                case 0x44114:
+                    r17 = r17 | 16;
+                    r2 = r17 & 16;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x444a8;
+                        run_44400(); return;
+                    }
+                case 0x4412c:
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    continue;
+                case 0x44150:
+                    r2 = 7 << 16;
+                    r2 = r2 + 228;
+                    writePages[(r29+240)>>>12][((r29+240)>>>2)&0x3ff] = r2;
+                    r2 = r17 & 16;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44390;
+                        run_44200(); return;
+                    }
+                case 0x44174:
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                case 0x44188:
+                    r3 = r17 & 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44ae0;
+                        run_44a00(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44ae0;
+                        run_44a00(); return;
+                    }
+                    r3 = r0 + 48;
+                    addr=r29+180;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+181;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r17 = r17 | 2;
+                    r4 = r0 + 2;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    continue;
+                case 0x441c0:
+                    r2 = r17 & 16;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4432c;
+                        run_44200(); return;
+                    }
+                case 0x441d8:
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                case 0x441ec:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44350;
+                        run_44200(); return;
+                    }
+                case 0x441f4:
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    continue;
+                case 0x44200:
+                    pc=0x44200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_44200() throws ExecutionException { /* 0x44200 - 0x44400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x44200:
+                case 0x44204:
+                    r17 = r17 | 64;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    run_43800(); return;
+                case 0x44214:
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    addr=r29+104;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                case 0x44234:
+                    r4 = r0 + 1;
+                    r5 = r0 + 1;
+                    r3 = r0 + r0;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r4;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r5;
+                    r30 = r0 + r0;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                    r16 = r29 + 104;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b58;
+                    run_43a00(); return;
+                case 0x4425c:
+                    r17 = r17 | 1;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    run_43800(); return;
+                case 0x4426c:
+                    r2 = r17 & 16;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d6c;
+                        run_44c00(); return;
+                    }
+                    r17 = r17 & 64;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d6c;
+                        run_44c00(); return;
+                    }
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x438b8;
+                    run_43800(); return;
+                case 0x442bc:
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r0 + 48;
+                    addr=r29+180;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + 120;
+                    addr=r29+181;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r17 = r17 | 2;
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    r3 = 7 << 16;
+                    r3 = r3 + 248;
+                    writePages[(r29+240)>>>12][((r29+240)>>>2)&0x3ff] = r3;
+                    r4 = r0 + 2;
+                    r18 = r0 + 120;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    run_44000(); return;
+                case 0x44310:
+                    r17 = r17 | 16;
+                    r2 = r17 & 16;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x441d8;
+                        run_44000(); return;
+                    }
+                case 0x4432c:
+                    r2 = r17 & 64;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4506c;
+                        run_45000(); return;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x441f4;
+                        run_44000(); return;
+                    }
+                case 0x44350:
+                    r3 = r0 + 45;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 - r2;
+                    r3 = r0 + 45;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    run_44000(); return;
+                case 0x4436c:
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    r3 = 7 << 16;
+                    r3 = r3 + 248;
+                    r2 = r17 & 16;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+240)>>>12][((r29+240)>>>2)&0x3ff] = r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44174;
+                        run_44000(); return;
+                    }
+                case 0x44390:
+                    r2 = r17 & 64;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45058;
+                        run_45000(); return;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x44188;
+                    run_44000(); return;
+                case 0x443b4:
+                    r2 = r17 & 8;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45044;
+                        run_45000(); return;
+                    }
+                    r4 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r3 = r4 + 7;
+                case 0x443d8:
+                    r2 = r0 + -8;
+                    r2 = r3 & r2;
+                    r3 = r2 + 8;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    f0 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f1 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff] = r8;
+                    writePages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff] = f0;
+                    f12 = readPages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff];
+                case 0x44400:
+                    pc=0x44400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_44400() throws ExecutionException { /* 0x44400 - 0x44600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x44400:
+                    writePages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff] = f1;
+                    f13 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x44410;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x44410:
+                    r3 = r0 + 1;
+                    r8 = readPages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff];
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44fe4;
+                        run_44e00(); return;
+                    }
+                    f0 = r0;
+                    f2 = readPages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x456e0;
+                        run_45600(); return;
+                    }
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                case 0x44448:
+                    r2 = r18 < 72 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45444;
+                        run_45400(); return;
+                    }
+                    r16 = 7 << 16;
+                    r16 = r16 + 216;
+                case 0x4445c:
+                    r2 = r0 + -129;
+                    r17 = r17 & r2;
+                    r4 = r0 + 3;
+                    r2 = r0 + 3;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r2;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r4;
+                    r30 = r0 + r0;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b40;
+                    run_43a00(); return;
+                case 0x44484:
+                    r17 = r17 | 8;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    run_43800(); return;
+                case 0x44494:
+                    r2 = r17 & 16;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4412c;
+                        run_44000(); return;
+                    }
+                case 0x444a8:
+                    r2 = r17 & 64;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45080;
+                        run_45000(); return;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    r4 = r0 + 1;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    run_44000(); return;
+                case 0x444d8:
+                    r2 = r17 & 16;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44088;
+                        run_44000(); return;
+                    }
+                case 0x444ec:
+                    r2 = r17 & 64;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x450a0;
+                        run_45000(); return;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    r4 = r0 + r0;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    run_44000(); return;
+                case 0x4451c:
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r2;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    run_43800(); return;
+                case 0x4452c:
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r7;
+                    writePages[(r29+312)>>>12][((r29+312)>>>2)&0x3ff] = r3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a2c;
+                        run_43a00(); return;
+                    }
+                    addr=r29+104;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x44234;
+                    run_44200(); return;
+                case 0x44550:
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x43c88;
+                    run_43c00(); return;
+                case 0x4455c:
+                    r4 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r2 = r2 + 1;
+                    r3 = r4 < 2 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x449cc;
+                        run_44800(); return;
+                    }
+                case 0x44580:
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44f34;
+                        run_44e00(); return;
+                    }
+                    r4 = readPages[(r29+232)>>>12][((r29+232)>>>2)&0x3ff];
+                    r8 = r8 + 8;
+                    r3 = r3 + 1;
+                    r5 = readPages[(r29+216)>>>12][((r29+216)>>>2)&0x3ff];
+                    r2 = r2 + r4;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r5;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44f88;
+                        run_44e00(); return;
+                    }
+                case 0x445cc:
+                    r8 = r8 + 8;
+                case 0x445d0:
+                    f0 = r0;
+                    f2 = readPages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44c4c;
+                        run_44c00(); return;
+                    }
+                    r5 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    r4 = r5 + -1;
+                case 0x44600:
+                    pc=0x44600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_44600() throws ExecutionException { /* 0x44600 - 0x44800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x44600:
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r2 = r2 + r4;
+                case 0x4460c:
+                    r3 = r3 + 1;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x449f4;
+                        run_44800(); return;
+                    }
+                case 0x44624:
+                    r8 = r8 + 8;
+                case 0x44628:
+                    r5 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r4 = r29 + 164;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r4;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r5;
+                    r2 = r5 + r2;
+                case 0x4463c:
+                    r3 = r3 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43e4c;
+                        run_43e00(); return;
+                    }
+                case 0x44654:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44668;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44668:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43e50;
+                    run_43e00(); return;
+                case 0x44680:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44694;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44694:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r0;
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43f8c;
+                    run_43e00(); return;
+                case 0x446ac:
+                    r5 = r0 + 1;
+                    if(r4 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44aa8;
+                        run_44a00(); return;
+                    }
+                    r6 = r29 + 144;
+                    r5 = r0 + 2;
+                    r16 = r6 + r0;
+                    if(r4 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44700;
+                        continue;
+                    }
+                    r5 = readPages[(r29+240)>>>12][((r29+240)>>>2)&0x3ff];
+                case 0x446d0:
+                    r4 = r2 & 15;
+                    r4 = r5 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r16 = r16 + -1;
+                    r2 = r2 >>> 4;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x446d0;
+                        continue;
+                    }
+                case 0x446f0:
+                    r6 = r6 - r16;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x440ec;
+                    run_44000(); return;
+                case 0x44700:
+                    r4 = r2 & 7;
+                    r16 = r16 + -1;
+                    r4 = r4 + 48;
+                    r2 = r2 >>> 3;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44700;
+                        continue;
+                    }
+                    r2 = r17 & 1;
+                    r5 = r16 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x446f0;
+                        continue;
+                    }
+                    r2 = r0 + 48;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x446f0;
+                        continue;
+                    }
+                    r16 = r16 + -1;
+                    r6 = r6 - r16;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x440ec;
+                    run_44000(); return;
+                case 0x44750:
+                    r18 = r18 < 102 ? 1 : 0;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4455c;
+                        run_44400(); return;
+                    }
+                    f0 = r0;
+                    f2 = readPages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44af4;
+                        run_44a00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r3 = r3 + 276;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 1;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r3 = r3 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x450d4;
+                        run_45000(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x447b8:
+                    r3 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r4 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r3 = r3 < r4 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x447dc;
+                        continue;
+                    }
+                    r3 = r17 & 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43e50;
+                        run_43e00(); return;
+                    }
+                case 0x447dc:
+                    r3 = readPages[(r29+216)>>>12][((r29+216)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+232)>>>12][((r29+232)>>>2)&0x3ff];
+                    r2 = r2 + r3;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                case 0x44800:
+                    pc=0x44800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_44800() throws ExecutionException { /* 0x44800 - 0x44a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x44800:
+                    r3 = r3 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45418;
+                        run_45400(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x44818:
+                    r3 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r16 = r3 + -1;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43e50;
+                        run_43e00(); return;
+                    }
+                    r3 = r16 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d08;
+                        run_44c00(); return;
+                    }
+                    r5 = 7 << 16;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r23 = r5 + 636;
+                    r18 = r0 + 16;
+                    r20 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x44868;
+                    continue;
+                case 0x44854:
+                    r8 = r8 + 8;
+                case 0x44858:
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d14;
+                        run_44c00(); return;
+                    }
+                case 0x44868:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r18;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44854;
+                        continue;
+                    }
+                    r4 = r20 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x448a0;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x448a0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44858;
+                    continue;
+                case 0x448bc:
+                    r3 = readPages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff];
+                    r4 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    r20 = r3 - r4;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43d18;
+                        run_43c00(); return;
+                    }
+                    r3 = r20 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4572c;
+                        run_45600(); return;
+                    }
+                    r4 = 7 << 16;
+                    r23 = r4 + 636;
+                    r4 = r23 + r0;
+                    writePages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff] = r16;
+                    r23 = r20 + r0;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r20 = r17 + r0;
+                    r7 = r0 + 16;
+                    r16 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r17 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44924;
+                    continue;
+                case 0x44910:
+                    r23 = r23 + -16;
+                    r4 = r23 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44988;
+                        continue;
+                    }
+                case 0x44924:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r17;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r7;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44910;
+                        continue;
+                    }
+                    r4 = r16 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    writePages[(r29+256)>>>12][((r29+256)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x44960;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44960:
+                    r7 = readPages[(r29+256)>>>12][((r29+256)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r23 = r23 + -16;
+                    r4 = r23 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44924;
+                        continue;
+                    }
+                case 0x44988:
+                    r4 = r17 + r0;
+                    r16 = readPages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff];
+                    r17 = r20 + r0;
+                    r20 = r23 + r0;
+                    r23 = r4 + r0;
+                case 0x4499c:
+                    r3 = r3 + 1;
+                    r2 = r2 + r20;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44fb8;
+                        run_44e00(); return;
+                    }
+                    r8 = r8 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x43d18;
+                    run_43c00(); return;
+                case 0x449cc:
+                    r3 = r17 & 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44580;
+                        run_44400(); return;
+                    }
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44624;
+                        run_44600(); return;
+                    }
+                case 0x449f4:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                case 0x44a00:
+                    pc=0x44a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_44a00() throws ExecutionException { /* 0x44a00 - 0x44c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x44a00:
+                    /* Next insn is delay slot */ 
+                    r31=0x44a08;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44a08:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44628;
+                    run_44600(); return;
+                case 0x44a24:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44a38;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44a38:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43e14;
+                    run_43e00(); return;
+                case 0x44a50:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44a64;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44a64:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43cc4;
+                    run_43c00(); return;
+                case 0x44a7c:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44a90;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44a90:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43d08;
+                    run_43c00(); return;
+                case 0x44aa8:
+                    r4 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d28;
+                        run_44c00(); return;
+                    }
+                    r2 = r2 + 48;
+                    r4 = r0 + 1;
+                    addr=r29+143;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r4;
+                    r16 = r29 + 143;
+                    /* Next insn is delay slot */ 
+                    pc=0x440ec;
+                    run_44000(); return;
+                case 0x44ad0:
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r0;
+                    r16 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    pc=0x440ec;
+                    run_44000(); return;
+                case 0x44ae0:
+                    r4 = r0 + 2;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    run_44000(); return;
+                case 0x44af4:
+                    r3 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45100;
+                        run_45000(); return;
+                    }
+                    r3 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r4 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    r18 = r16 + r3;
+                    r20 = r18 - r16;
+                    r3 = r4 < r20 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44b24;
+                        continue;
+                    }
+                    r20 = r4 + r0;
+                case 0x44b24:
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44b58;
+                        continue;
+                    }
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r2 = r2 + r20;
+                    r3 = r3 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45568;
+                        run_45400(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x44b58:
+                    if(r20 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4555c;
+                        run_45400(); return;
+                    }
+                case 0x44b60:
+                    r3 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    r20 = r3 - r20;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44ddc;
+                        run_44c00(); return;
+                    }
+                    r3 = r20 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45a94;
+                        run_45a00(); return;
+                    }
+                    r5 = 7 << 16;
+                    r23 = r5 + 636;
+                    r4 = r23 + r0;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r16;
+                    r23 = r20 + r0;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r20 = r18 + r0;
+                    r30 = r0 + 16;
+                    r18 = r17 + r0;
+                    r16 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r17 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44bc8;
+                    continue;
+                case 0x44bb4:
+                    r8 = r8 + 8;
+                case 0x44bb8:
+                    r23 = r23 + -16;
+                    r4 = r23 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d9c;
+                        run_44c00(); return;
+                    }
+                case 0x44bc8:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r17;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r30;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44bb4;
+                        continue;
+                    }
+                    r4 = r16 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44c00;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44c00:
+                    pc=0x44c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_44c00() throws ExecutionException { /* 0x44c00 - 0x44e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x44c00:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44bb8;
+                    run_44a00(); return;
+                case 0x44c1c:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44c30;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44c30:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43c88;
+                    run_43c00(); return;
+                case 0x44c4c:
+                    r4 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r16 = r4 + -1;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44628;
+                        run_44600(); return;
+                    }
+                    r4 = r16 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45a84;
+                        run_45a00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r23 = r4 + 636;
+                    r18 = r0 + 16;
+                    r20 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x44c98;
+                    continue;
+                case 0x44c84:
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44cf4;
+                        continue;
+                    }
+                case 0x44c98:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r18;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44c84;
+                        continue;
+                    }
+                    r4 = r20 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44cd0;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44cd0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44c98;
+                        continue;
+                    }
+                case 0x44cf4:
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r16;
+                    r2 = r2 + r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x4460c;
+                    run_44600(); return;
+                case 0x44d08:
+                    r4 = 7 << 16;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r23 = r4 + 636;
+                case 0x44d14:
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r16;
+                    r2 = r2 + r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x4463c;
+                    run_44600(); return;
+                case 0x44d28:
+                    r6 = r29 + 144;
+                    r16 = r6 + r0;
+                    r4 = r0 + 10;
+                case 0x44d34:
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r4!=0) {
+                        hi = (int)((r2 & 0xffffffffL) % (r4 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r4 & 0xffffffffL));
+                        }
+                        pc=0x44d40;
+                        continue;
+                    }
+                    if(r4!=0) {
+                    hi = (int)((r2 & 0xffffffffL) % (r4 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r4 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x44d40:
+                    r16 = r16 + -1;
+                    r5 = hi;
+                    r5 = r5 + 48;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = lo;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d34;
+                        continue;
+                    }
+                    r6 = r6 - r16;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x440ec;
+                    run_44000(); return;
+                case 0x44d6c:
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x438b8;
+                    run_43800(); return;
+                case 0x44d9c:
+                    r4 = r17 + r0;
+                    r16 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                    r17 = r18 + r0;
+                    r18 = r20 + r0;
+                    r20 = r23 + r0;
+                    r23 = r4 + r0;
+                case 0x44db4:
+                    r3 = r3 + 1;
+                    r2 = r2 + r20;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45650;
+                        run_45600(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x44ddc:
+                    r3 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    r5 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r16 = r16 + r3;
+                    r3 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r4 = r3 < r5 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44e08;
+                        run_44e00(); return;
+                    }
+                    r4 = r17 & 1;
+                case 0x44e00:
+                    pc=0x44e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_44e00() throws ExecutionException { /* 0x44e00 - 0x45000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x44e00:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44e3c;
+                        continue;
+                    }
+                case 0x44e08:
+                    r4 = readPages[(r29+216)>>>12][((r29+216)>>>2)&0x3ff];
+                    r5 = readPages[(r29+232)>>>12][((r29+232)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r2 = r2 + r5;
+                    r4 = r4 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r4;
+                    r4 = r4 < 8 ? 1 : 0;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r5;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x455cc;
+                        run_45400(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x44e3c:
+                    r4 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r18 = r18 - r16;
+                    r3 = r4 - r3;
+                    r4 = r18 < r3 ? 1 : 0;
+                    r20 = r3 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44e5c;
+                        continue;
+                    }
+                    r20 = r18 + r0;
+                case 0x44e5c:
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44e90;
+                        continue;
+                    }
+                    r4 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r2 = r2 + r20;
+                    r4 = r4 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r4;
+                    r4 = r4 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4567c;
+                        run_45600(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x44e90:
+                    if(r20 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x456b4;
+                        run_45600(); return;
+                    }
+                case 0x44e98:
+                    r16 = r3 - r20;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43e50;
+                        run_43e00(); return;
+                    }
+                    r3 = r16 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d08;
+                        run_44c00(); return;
+                    }
+                    r5 = 7 << 16;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r23 = r5 + 636;
+                    r18 = r0 + 16;
+                    r20 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x44ee0;
+                    continue;
+                case 0x44ecc:
+                    r8 = r8 + 8;
+                case 0x44ed0:
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44d14;
+                        run_44c00(); return;
+                    }
+                case 0x44ee0:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r18;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x44ecc;
+                        continue;
+                    }
+                    r4 = r20 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44f18;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44f18:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44ed0;
+                    continue;
+                case 0x44f34:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44f48;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44f48:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r4 = readPages[(r29+232)>>>12][((r29+232)>>>2)&0x3ff];
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    r3 = r3 + 1;
+                    r5 = readPages[(r29+216)>>>12][((r29+216)>>>2)&0x3ff];
+                    r2 = r2 + r4;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r5;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x445cc;
+                        run_44400(); return;
+                    }
+                case 0x44f88:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44f9c;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44f9c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x445d0;
+                    run_44400(); return;
+                case 0x44fb8:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x44fcc;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x44fcc:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43d18;
+                    run_43c00(); return;
+                case 0x44fe4:
+                    f12 = readPages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff];
+                    writePages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff] = r8;
+                    f13 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x44ff8;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x44ff8:
+                    r8 = readPages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45234;
+                        run_45200(); return;
+                    }
+                case 0x45000:
+                    pc=0x45000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_45000() throws ExecutionException { /* 0x45000 - 0x45200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x45000:
+                    r2 = r18 < 72 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45494;
+                        run_45400(); return;
+                    }
+                    r16 = 7 << 16;
+                    r16 = r16 + 224;
+                case 0x45018:
+                    r2 = r0 + -129;
+                    r17 = r17 & r2;
+                    r5 = r0 + 3;
+                    r2 = r0 + 3;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r5;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r2;
+                    r30 = r0 + r0;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b40;
+                    run_43a00(); return;
+                case 0x45044:
+                    r2 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r3 = r2 + 7;
+                    /* Next insn is delay slot */ 
+                    pc=0x443d8;
+                    run_44200(); return;
+                case 0x45058:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x44188;
+                    run_44000(); return;
+                case 0x4506c:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x441ec;
+                    run_44000(); return;
+                case 0x45080:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    r4 = r0 + 1;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    run_44000(); return;
+                case 0x450a0:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r3;
+                    r4 = r0 + r0;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x440a4;
+                    run_44000(); return;
+                case 0x450c0:
+                    r4 = 7 << 16;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r23 = r4 + 636;
+                    /* Next insn is delay slot */ 
+                    pc=0x43dec;
+                    run_43c00(); return;
+                case 0x450d4:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x450e8;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x450e8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x447b8;
+                    run_44600(); return;
+                case 0x45100:
+                    r4 = 7 << 16;
+                    r4 = r4 + 276;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r4;
+                    r4 = r0 + 1;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r4 = r4 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r4;
+                    r4 = r4 < 8 ? 1 : 0;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x454a4;
+                        run_45400(); return;
+                    }
+                    r8 = r8 + 8;
+                    r18 = r3 + r0;
+                case 0x4513c:
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45160;
+                        continue;
+                    }
+                    r3 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45160;
+                        continue;
+                    }
+                    r3 = r17 & 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43e50;
+                        run_43e00(); return;
+                    }
+                case 0x45160:
+                    r3 = readPages[(r29+216)>>>12][((r29+216)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+232)>>>12][((r29+232)>>>2)&0x3ff];
+                    r2 = r2 + r3;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    r3 = r3 + 1;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x458e0;
+                        run_45800(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x4519c:
+                    r18 = r0 - r18;
+                    if(r18 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45530;
+                        run_45400(); return;
+                    }
+                    r4 = r18 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45594;
+                        run_45400(); return;
+                    }
+                    r5 = 7 << 16;
+                    r23 = r5 + 636;
+                    r20 = r0 + 16;
+                    r30 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x451e0;
+                    continue;
+                case 0x451cc:
+                    r8 = r8 + 8;
+                case 0x451d0:
+                    r18 = r18 + -16;
+                    r4 = r18 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4559c;
+                        run_45400(); return;
+                    }
+                case 0x451e0:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x451cc;
+                        continue;
+                    }
+                case 0x45200:
+                    pc=0x45200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_45200() throws ExecutionException { /* 0x45200 - 0x45400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x45200:
+                    r4 = r30 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x45218;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x45218:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x451d0;
+                    run_45000(); return;
+                case 0x45234:
+                    r9 = r0 + -33;
+                    r2 = r0 + -1;
+                    r20 = r18 & r9;
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x454d4;
+                        run_45400(); return;
+                    }
+                    r2 = r0 + 71;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x458cc;
+                        run_45800(); return;
+                    }
+                case 0x45254:
+                    r2 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    r23 = r17 | 256;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45914;
+                        run_45800(); return;
+                    }
+                    f0 = readPages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff];
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r0;
+                    f1 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    writePages[(r29+252)>>>12][((r29+252)>>>2)&0x3ff] = f0;
+                    writePages[(r29+248)>>>12][((r29+248)>>>2)&0x3ff] = f1;
+                case 0x4527c:
+                    r2 = r0 + 102;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45740;
+                        run_45600(); return;
+                    }
+                    r2 = r0 + 70;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45740;
+                        run_45600(); return;
+                    }
+                    r2 = r0 + 69;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4593c;
+                        run_45800(); return;
+                    }
+                    r5 = r30 + r0;
+                case 0x452a4:
+                    r2 = r0 + 2;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 176;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 172;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r2 = r29 + 156;
+                    r7 = readPages[(r29+252)>>>12][((r29+252)>>>2)&0x3ff];
+                    r6 = readPages[(r29+248)>>>12][((r29+248)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    writePages[(r29+256)>>>12][((r29+256)>>>2)&0x3ff] = r5;
+                    writePages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x452e4;
+                    pc=0x57400;
+                    run_57400(); return;
+                case 0x452e4:
+                    r16 = r2 + r0;
+                    r2 = r0 + 103;
+                    r5 = readPages[(r29+256)>>>12][((r29+256)>>>2)&0x3ff];
+                    r8 = readPages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff];
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45308;
+                        continue;
+                    }
+                    r2 = r0 + 71;
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45314;
+                        continue;
+                    }
+                case 0x45308:
+                    r2 = r17 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45a6c;
+                        run_45a00(); return;
+                    }
+                case 0x45314:
+                    r2 = r0 + 70;
+                    r4 = r16 + r5;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4584c;
+                        run_45800(); return;
+                    }
+                case 0x45324:
+                    f0 = r0;
+                    f2 = readPages[(r29+252)>>>12][((r29+252)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+248)>>>12][((r29+248)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45720;
+                        run_45600(); return;
+                    }
+                    r2 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    r3 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45380;
+                        continue;
+                    }
+                    r5 = r0 + 48;
+                case 0x45360:
+                    r3 = r2 + 1;
+                    writePages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff] = r3;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    r3 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45360;
+                        continue;
+                    }
+                case 0x45380:
+                    r2 = r2 - r16;
+                    writePages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 71;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x456f4;
+                        run_45600(); return;
+                    }
+                    r2 = r18 < 102 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45b80;
+                        run_45a00(); return;
+                    }
+                    r3 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r2 = r0 + 102;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r3;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x459ac;
+                        run_45800(); return;
+                    }
+                case 0x453b4:
+                    r3 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r4 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    r2 = r4 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45948;
+                        run_45800(); return;
+                    }
+                    r17 = r17 & 1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45980;
+                        run_45800(); return;
+                    }
+                    r2 = r4 + r0;
+                    if(r4 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45b64;
+                        run_45a00(); return;
+                    }
+                case 0x453e4:
+                    r3 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    r18 = r0 + 103;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r3;
+                case 0x453f0:
+                    r5 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x456c0;
+                        run_45600(); return;
+                    }
+                case 0x45400:
+                    pc=0x45400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_45400() throws ExecutionException { /* 0x45400 - 0x45600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x45400:
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r2;
+                    r17 = r23 + r0;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b40;
+                    run_43a00(); return;
+                case 0x45418:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x4542c;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x4542c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44818;
+                    run_44800(); return;
+                case 0x45444:
+                    r16 = 7 << 16;
+                    r16 = r16 + 212;
+                    /* Next insn is delay slot */ 
+                    pc=0x4445c;
+                    run_44400(); return;
+                case 0x45454:
+                    r30 = r0 + -1;
+                    r3 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43994;
+                    run_43800(); return;
+                case 0x45464:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r0 + 64;
+                    /* Next insn is delay slot */ 
+                    r31=0x45474;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x45474:
+                    writePages[(r22+0)>>>12][((r22+0)>>>2)&0x3ff] = r2;
+                    writePages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45b8c;
+                        run_45a00(); return;
+                    }
+                    r2 = r0 + 64;
+                    writePages[(r22+20)>>>12][((r22+20)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x43884;
+                    run_43800(); return;
+                case 0x45494:
+                    r16 = 7 << 16;
+                    r16 = r16 + 220;
+                    /* Next insn is delay slot */ 
+                    pc=0x45018;
+                    run_45000(); return;
+                case 0x454a4:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x454b8;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x454b8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r18 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4513c;
+                    run_45000(); return;
+                case 0x454d4:
+                    r30 = r0 + 6;
+                    /* Next insn is delay slot */ 
+                    pc=0x45254;
+                    run_45200(); return;
+                case 0x454e0:
+                    writePages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x454ec;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x454ec:
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r2;
+                    r8 = readPages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff];
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43b2c;
+                        run_43a00(); return;
+                    }
+                case 0x454fc:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b2c;
+                    run_43a00(); return;
+                case 0x45508:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x4551c;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x4551c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                case 0x45530:
+                    r4 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r2 = r4 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x4463c;
+                    run_44600(); return;
+                case 0x45548:
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    writePages[(r29+220)>>>12][((r29+220)>>>2)&0x3ff] = r19;
+                    /* Next insn is delay slot */ 
+                    pc=0x43c58;
+                    run_43c00(); return;
+                case 0x4555c:
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44b60;
+                    run_44a00(); return;
+                case 0x45568:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x4557c;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x4557c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44b58;
+                    run_44a00(); return;
+                case 0x45594:
+                    r4 = 7 << 16;
+                    r23 = r4 + 636;
+                case 0x4559c:
+                    r3 = r3 + 1;
+                    r2 = r2 + r18;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r18;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45508;
+                        continue;
+                    }
+                    r8 = r8 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x45530;
+                    continue;
+                case 0x455cc:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x455e0;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x455e0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r3 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44e3c;
+                    run_44e00(); return;
+                case 0x455fc:
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                case 0x45600:
+                    pc=0x45600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_45600() throws ExecutionException { /* 0x45600 - 0x45800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x45600:
+                    writePages[(r29+220)>>>12][((r29+220)>>>2)&0x3ff] = r19;
+                    /* Next insn is delay slot */ 
+                    pc=0x43f08;
+                    run_43e00(); return;
+                case 0x4560c:
+                    r3 = (r30&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r2 = r30 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45620;
+                        continue;
+                    }
+                    r2 = r0 + 6;
+                case 0x45620:
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45a78;
+                        run_45a00(); return;
+                    }
+                case 0x4562c:
+                    r16 = 7 << 16;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r2;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r20;
+                    r3 = r0 + r0;
+                    r30 = r0 + r0;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                    r16 = r16 + 268;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b58;
+                    run_43a00(); return;
+                case 0x45650:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x45664;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x45664:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44ddc;
+                    run_44c00(); return;
+                case 0x4567c:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x45690;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x45690:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r3 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = r5 - r3;
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44e90;
+                    run_44e00(); return;
+                case 0x456b4:
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x44e98;
+                    run_44e00(); return;
+                case 0x456c0:
+                    r3 = r0 + 45;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r2;
+                    r17 = r23 + r0;
+                    r3 = r0 + 45;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b48;
+                    run_43a00(); return;
+                case 0x456e0:
+                    r2 = r0 + 45;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + 45;
+                    /* Next insn is delay slot */ 
+                    pc=0x44448;
+                    run_44400(); return;
+                case 0x456f4:
+                    r2 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r3 = r2 < -3 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45790;
+                        continue;
+                    }
+                    r3 = r30 < r2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45790;
+                        continue;
+                    }
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x453b4;
+                    run_45200(); return;
+                case 0x45720:
+                    r2 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45380;
+                    run_45200(); return;
+                case 0x4572c:
+                    r5 = 7 << 16;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r23 = r5 + 636;
+                    /* Next insn is delay slot */ 
+                    pc=0x4499c;
+                    run_44800(); return;
+                case 0x45740:
+                    r2 = r0 + 3;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 176;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 172;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r2 = r29 + 156;
+                    r7 = readPages[(r29+252)>>>12][((r29+252)>>>2)&0x3ff];
+                    r6 = readPages[(r29+248)>>>12][((r29+248)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r30;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    writePages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x4577c;
+                    pc=0x57400;
+                    run_57400(); return;
+                case 0x4577c:
+                    r16 = r2 + r0;
+                    r5 = r30 + r0;
+                    r8 = readPages[(r29+260)>>>12][((r29+260)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x45314;
+                    run_45200(); return;
+                case 0x45790:
+                    r18 = r18 + -2;
+                case 0x45794:
+                    r2 = r2 + -1;
+                    writePages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff] = r2;
+                    addr=r29+164;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45b34;
+                        run_45a00(); return;
+                    }
+                    r3 = r0 + 43;
+                    addr=r29+165;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x457b0:
+                    r3 = r2 < 10 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x459d8;
+                        run_45800(); return;
+                    }
+                    r2 = r2 + 48;
+                    r3 = r0 + 48;
+                    addr=r29+167;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+166;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r29 + 168;
+                    r4 = r29 + 164;
+                case 0x457d4:
+                    r3 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r4 = r2 - r4;
+                    r3 = r3 + r4;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r4;
+                    r2 = r3 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45820;
+                        run_45800(); return;
+                    }
+                case 0x457f8:
+                    r3 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                case 0x45800:
+                    pc=0x45800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_45800() throws ExecutionException { /* 0x45800 - 0x45a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x45800:
+                    r3 = r3 + 1;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r3;
+                    r2 = r3 + r0;
+                    if(r3 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4583c;
+                        continue;
+                    }
+                case 0x45814:
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x453f0;
+                    run_45200(); return;
+                case 0x45820:
+                    r17 = r17 & 1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x457f8;
+                        run_45600(); return;
+                    }
+                    r2 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45814;
+                        continue;
+                    }
+                case 0x4583c:
+                    r2 = r0 + r0;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x453f0;
+                    run_45200(); return;
+                case 0x4584c:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 48;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45870;
+                        continue;
+                    }
+                case 0x4585c:
+                    r2 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r4 = r4 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x45324;
+                    run_45200(); return;
+                case 0x45870:
+                    f0 = r0;
+                    f2 = readPages[(r29+252)>>>12][((r29+252)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+248)>>>12][((r29+248)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4585c;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    r2 = r2 - r5;
+                    writePages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff] = r2;
+                    r4 = r4 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x45324;
+                    run_45200(); return;
+                case 0x458ac:
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r30;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r30;
+                    addr=r29+182;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r20;
+                    r30 = r0 + r0;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x43b40;
+                    run_43a00(); return;
+                case 0x458cc:
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45254;
+                        run_45200(); return;
+                    }
+                    r30 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x45254;
+                    run_45200(); return;
+                case 0x458e0:
+                    r4 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    r31=0x458f4;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x458f4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x43a50;
+                        run_43a00(); return;
+                    }
+                    r18 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    r2 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r8 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4519c;
+                    run_45000(); return;
+                case 0x45914:
+                    r3 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    r2 = 32768 << 16;
+                    r4 = readPages[(r29+228)>>>12][((r29+228)>>>2)&0x3ff];
+                    r2 = r3 ^ r2;
+                    r5 = r0 + 45;
+                    writePages[(r29+248)>>>12][((r29+248)>>>2)&0x3ff] = r2;
+                    writePages[(r29+252)>>>12][((r29+252)>>>2)&0x3ff] = r4;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x4527c;
+                    run_45200(); return;
+                case 0x4593c:
+                    r5 = r30 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x452a4;
+                    run_45200(); return;
+                case 0x45948:
+                    r3 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45af4;
+                        run_45a00(); return;
+                    }
+                    r2 = r0 + 1;
+                case 0x4595c:
+                    r3 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r2 = r2 + r3;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4599c;
+                        continue;
+                    }
+                case 0x45974:
+                    r18 = r0 + 103;
+                    /* Next insn is delay slot */ 
+                    pc=0x453f0;
+                    run_45200(); return;
+                case 0x45980:
+                    r3 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r3;
+                    r2 = r3 + r0;
+                    if(r3 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45974;
+                        continue;
+                    }
+                case 0x4599c:
+                    r2 = r0 + r0;
+                    r18 = r0 + 103;
+                    /* Next insn is delay slot */ 
+                    pc=0x453f0;
+                    run_45200(); return;
+                case 0x459ac:
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45acc;
+                        run_45a00(); return;
+                    }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45aa8;
+                        run_45a00(); return;
+                    }
+                    r17 = r17 & 1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45aa8;
+                        run_45a00(); return;
+                    }
+                    r2 = r3 + r0;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x453f0;
+                    run_45200(); return;
+                case 0x459d8:
+                    r6 = r29 + 163;
+                    r3 = r6 + r0;
+                    r4 = r0 + 10;
+                case 0x459e4:
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        hi = r2%r4; lo = r2/r4;
+                        pc=0x459f0;
+                        continue;
+                    }
+                    hi = r2%r4; lo = r2/r4;
+                    throw new ExecutionException("Break");
+                case 0x459f0:
+                    r3 = r3 + -1;
+                    r5 = hi;
+                    r5 = r5 + 48;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x45a00:
+                    pc=0x45a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_45a00() throws ExecutionException { /* 0x45a00 - 0x45c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x45a00:
+                    r2 = lo;
+                    r5 = r2 < 10 ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x459e4;
+                        run_45800(); return;
+                    }
+                    r2 = r2 + 48;
+                    r5 = r2 << 24;
+                    r4 = r3 + -1;
+                    r5 = r5 >> 24;
+                    r2 = ((r4 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45b70;
+                        continue;
+                    }
+                    r2 = r29 + 166;
+                    /* Next insn is delay slot */ 
+                    pc=0x45a40;
+                    continue;
+                case 0x45a3c:
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                case 0x45a40:
+                    r2 = r2 + 1;
+                    r4 = r4 + 1;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r4 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45a3c;
+                        continue;
+                    }
+                    r4 = r29 + 164;
+                    r2 = r4 - r3;
+                    r3 = r29 + 166;
+                    r2 = r3 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x457d4;
+                    run_45600(); return;
+                case 0x45a6c:
+                    r2 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x45380;
+                    run_45200(); return;
+                case 0x45a78:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4562c;
+                    run_45600(); return;
+                case 0x45a84:
+                    r5 = 7 << 16;
+                    r23 = r5 + 636;
+                    /* Next insn is delay slot */ 
+                    pc=0x44cf4;
+                    run_44c00(); return;
+                case 0x45a94:
+                    r4 = 7 << 16;
+                    r3 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r23 = r4 + 636;
+                    /* Next insn is delay slot */ 
+                    pc=0x44db4;
+                    run_44c00(); return;
+                case 0x45aa8:
+                    r3 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    r2 = r30 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x453f0;
+                        run_45200(); return;
+                    }
+                case 0x45ac0:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x453f0;
+                    run_45200(); return;
+                case 0x45acc:
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45b48;
+                        continue;
+                    }
+                    r17 = r17 & 1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45b48;
+                        continue;
+                    }
+                    r3 = r0 + 1;
+                    r2 = r0 + 1;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x453f0;
+                    run_45200(); return;
+                case 0x45af4:
+                    r2 = r0 + 2;
+                    r2 = r2 - r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x4595c;
+                    run_45800(); return;
+                case 0x45b04:
+                    r3 = readPages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff];
+                    r30 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r3 + 4;
+                    r3 = r4 + r0;
+                    if(r30 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4451c;
+                        run_44400(); return;
+                    }
+                    writePages[(r29+316)>>>12][((r29+316)>>>2)&0x3ff] = r2;
+                    r30 = r0 + -1;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4398c;
+                    run_43800(); return;
+                case 0x45b34:
+                    r3 = r0 + 45;
+                    r2 = r0 - r2;
+                    addr=r29+165;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x457b0;
+                    run_45600(); return;
+                case 0x45b48:
+                    r30 = r30 + 2;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r30;
+                    r2 = r30 + r0;
+                    if(r30 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x453f0;
+                        run_45200(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x45ac0;
+                    continue;
+                case 0x45b64:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x453e4;
+                    run_45200(); return;
+                case 0x45b70:
+                    r2 = r29 + 166;
+                    r4 = r29 + 164;
+                    /* Next insn is delay slot */ 
+                    pc=0x457d4;
+                    run_45600(); return;
+                case 0x45b80:
+                    r2 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x45794;
+                    run_45600(); return;
+                case 0x45b8c:
+                    r3 = readPages[(r29+304)>>>12][((r29+304)>>>2)&0x3ff];
+                    r2 = r0 + 12;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x43a68;
+                    run_43a00(); return;
+                case 0x45c00:
+                    pc=0x45c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_45c00() throws ExecutionException { /* 0x45c00 - 0x45e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x45c00:
+                    r29 = r29 + -1328;
+                    writePages[(r29+1324)>>>12][((r29+1324)>>>2)&0x3ff] = r31;
+                    writePages[(r29+1312)>>>12][((r29+1312)>>>2)&0x3ff] = r22;
+                    writePages[(r29+1308)>>>12][((r29+1308)>>>2)&0x3ff] = r21;
+                    r22 = r5 + r0;
+                    r21 = r4 + r0;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r6;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1320)>>>12][((r29+1320)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1316)>>>12][((r29+1316)>>>2)&0x3ff] = r23;
+                    writePages[(r29+1304)>>>12][((r29+1304)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1300)>>>12][((r29+1300)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1296)>>>12][((r29+1296)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1292)>>>12][((r29+1292)>>>2)&0x3ff] = r17;
+                    writePages[(r29+1288)>>>12][((r29+1288)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x45c44;
+                    pc=0x5ae00;
+                    run_5ae00(); return;
+                case 0x45c44:
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    writePages[(r29+1236)>>>12][((r29+1236)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x45c5c;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x45c5c:
+                    writePages[(r29+1256)>>>12][((r29+1256)>>>2)&0x3ff] = r2;
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45c78;
+                        continue;
+                    }
+                    r2 = readPages[(r21+56)>>>12][((r21+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fec;
+                        run_45e00(); return;
+                    }
+                case 0x45c78:
+                    addr=r22+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r2 = r3 & 65535;
+                    r4 = r2 & 8192;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45cac;
+                        continue;
+                    }
+                    r4 = readPages[(r22+100)>>>12][((r22+100)>>>2)&0x3ff];
+                    r2 = r0 + -8193;
+                    r3 = r3 | 8192;
+                    r2 = r4 & r2;
+                    writePages[(r22+100)>>>12][((r22+100)>>>2)&0x3ff] = r2;
+                    addr=r22+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r3 & 65535;
+                case 0x45cac:
+                    r4 = r2 & 8;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45e58;
+                        run_45e00(); return;
+                    }
+                    r4 = readPages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45e58;
+                        run_45e00(); return;
+                    }
+                    r2 = r2 & 26;
+                    r4 = r0 + 10;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45e88;
+                        run_45e00(); return;
+                    }
+                case 0x45cd8:
+                    r3 = r29 + 40;
+                    r2 = 7 << 16;
+                    writePages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff] = r3;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1264)>>>12][((r29+1264)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff] = r0;
+                    r8 = r3 + r0;
+                    r19 = r2 + 1040;
+                case 0x45d0c:
+                    r3 = readPages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x464a4;
+                        run_46400(); return;
+                    }
+                case 0x45d24:
+                    r3 = r0 + 37;
+                    r16 = readPages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff];
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45d44;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x45db0;
+                    continue;
+                case 0x45d3c:
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45d58;
+                        continue;
+                    }
+                case 0x45d44:
+                    r16 = r16 + 1;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45d3c;
+                        continue;
+                    }
+                case 0x45d58:
+                    r3 = readPages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff];
+                    r17 = r16 - r3;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45db0;
+                        continue;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff];
+                    r2 = r2 + r17;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r2 = r2 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r2;
+                    r2 = r2 < 8 ? 1 : 0;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r17;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45f80;
+                        run_45e00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x45da0:
+                    r3 = readPages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff];
+                    r3 = r3 + r17;
+                    writePages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff] = r3;
+                case 0x45db0:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fa8;
+                        run_45e00(); return;
+                    }
+                    r16 = r16 + 1;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r5 = r0 + r0;
+                    r30 = r0 + -1;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r0;
+                    r17 = r0 + r0;
+                    r6 = r0 + 42;
+                    r7 = r0 + r0;
+                case 0x45de0:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r3 = r16 + 1;
+                case 0x45de8:
+                    r2 = r18 + -32;
+                    r4 = (r2&0xffffffffL) < (89&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a10;
+                        run_46a00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r2 = r2 << 2;
+                case 0x45e00:
+                    pc=0x45e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_45e00() throws ExecutionException { /* 0x45e00 - 0x46000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x45e00:
+                    r4 = r4 + 668;
+                    r2 = r4 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x45e18:
+                    r17 = r17 | 16;
+                case 0x45e1c:
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x45e28:
+                    r4 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r7 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r4 + 4;
+                    if(r7 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a00;
+                        run_46a00(); return;
+                    }
+                    r7 = r0 - r7;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r2;
+                case 0x45e48:
+                    r17 = r17 | 4;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x45e58:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x45e68;
+                    pc=0x48600;
+                    run_48600(); return;
+                case 0x45e68:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45f48;
+                        continue;
+                    }
+                    addr=r22+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r4 = r0 + 10;
+                    r2 = r3 & 65535;
+                    r2 = r2 & 26;
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45cd8;
+                        run_45c00(); return;
+                    }
+                case 0x45e88:
+                    addr=r22+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45cd8;
+                        run_45c00(); return;
+                    }
+                    addr=r29+1078;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r22+28)>>>12][((r22+28)>>>2)&0x3ff];
+                    r4 = r0 + -3;
+                    writePages[(r29+1092)>>>12][((r29+1092)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r22+36)>>>12][((r22+36)>>>2)&0x3ff];
+                    r3 = r3 & r4;
+                    addr=r29+1076;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1100)>>>12][((r29+1100)>>>2)&0x3ff] = r2;
+                    r3 = readPages[(r22+100)>>>12][((r22+100)>>>2)&0x3ff];
+                    r2 = r29 + 40;
+                    r6 = readPages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff];
+                    r7 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    writePages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff] = r2;
+                    r4 = r21 + r0;
+                    r2 = r0 + 1024;
+                    r5 = r29 + 1064;
+                    writePages[(r29+1164)>>>12][((r29+1164)>>>2)&0x3ff] = r3;
+                    writePages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1088)>>>12][((r29+1088)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x45ef4;
+                    pc=0x45c00;
+                    run_45c00(); return;
+                case 0x45ef4:
+                    r16 = r2 + r0;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45f18;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r29 + 1064;
+                    /* Next insn is delay slot */ 
+                    r31=0x45f10;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x45f10:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47f78;
+                        run_47e00(); return;
+                    }
+                case 0x45f18:
+                    addr=r29+1076;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45f3c;
+                        continue;
+                    }
+                    addr=r22+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 64;
+                    addr=r22+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x45f3c:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45f4c;
+                    continue;
+                case 0x45f48:
+                    r2 = r0 + -1;
+                case 0x45f4c:
+                    r31 = readPages[(r29+1324)>>>12][((r29+1324)>>>2)&0x3ff];
+                    r30 = readPages[(r29+1320)>>>12][((r29+1320)>>>2)&0x3ff];
+                    r23 = readPages[(r29+1316)>>>12][((r29+1316)>>>2)&0x3ff];
+                    r22 = readPages[(r29+1312)>>>12][((r29+1312)>>>2)&0x3ff];
+                    r21 = readPages[(r29+1308)>>>12][((r29+1308)>>>2)&0x3ff];
+                    r20 = readPages[(r29+1304)>>>12][((r29+1304)>>>2)&0x3ff];
+                    r19 = readPages[(r29+1300)>>>12][((r29+1300)>>>2)&0x3ff];
+                    r18 = readPages[(r29+1296)>>>12][((r29+1296)>>>2)&0x3ff];
+                    r17 = readPages[(r29+1292)>>>12][((r29+1292)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1288)>>>12][((r29+1288)>>>2)&0x3ff];
+                    r29 = r29 + 1328;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x45f80:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x45f94;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x45f94:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        continue;
+                    }
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x45da0;
+                    run_45c00(); return;
+                case 0x45fa8:
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x45fcc;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x45fcc:
+                    addr=r22+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45f48;
+                        continue;
+                    }
+                    r2 = readPages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x45f4c;
+                    continue;
+                case 0x45fec:
+                    r4 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x45ff8;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x45ff8:
+                    /* Next insn is delay slot */ 
+                    pc=0x45c78;
+                    run_45c00(); return;
+                case 0x46000:
+                    pc=0x46000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_46000() throws ExecutionException { /* 0x46000 - 0x46200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x46000:
+                    r5 = r0 + 43;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x46010:
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    r16 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r20 = r3 + 4;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47aa4;
+                        run_47a00(); return;
+                    }
+                    r4 = r16 + r0;
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47984;
+                        run_47800(); return;
+                    }
+                    r5 = r0 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x46050;
+                    pc=0x5b400;
+                    run_5b400(); return;
+                case 0x46050:
+                    r8 = readPages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47c38;
+                        run_47c00(); return;
+                    }
+                    r2 = r2 - r16;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r2;
+                    r2 = r30 < r2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4787c;
+                        run_47800(); return;
+                    }
+                case 0x46070:
+                    r2 = readPages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x479a0;
+                        run_47800(); return;
+                    }
+                case 0x46080:
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r20;
+                    r30 = r0 + r0;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                case 0x46094:
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x460ac;
+                        continue;
+                    }
+                case 0x4609c:
+                    r2 = readPages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r2;
+                case 0x460ac:
+                    r4 = r17 & 2;
+                    writePages[(r29+1224)>>>12][((r29+1224)>>>2)&0x3ff] = r4;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x460cc;
+                        continue;
+                    }
+                    r5 = readPages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff];
+                    r5 = r5 + 2;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r5;
+                case 0x460cc:
+                    r2 = r17 & 132;
+                    writePages[(r29+1228)>>>12][((r29+1228)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a64;
+                        run_46a00(); return;
+                    }
+                    r4 = readPages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff];
+                    r20 = r4 - r5;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a64;
+                        run_46a00(); return;
+                    }
+                    r2 = r20 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x479ac;
+                        run_47800(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    writePages[(r29+1244)>>>12][((r29+1244)>>>2)&0x3ff] = r19;
+                    r23 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x4612c;
+                    continue;
+                case 0x46118:
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46188;
+                        continue;
+                    }
+                case 0x4612c:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r19;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r23;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46118;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46164;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46164:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4612c;
+                        continue;
+                    }
+                case 0x46188:
+                    r3 = r3 + 1;
+                    r4 = readPages[(r29+1244)>>>12][((r29+1244)>>>2)&0x3ff];
+                    r2 = r20 + r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r4;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x470e4;
+                        run_47000(); return;
+                    }
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r8 = r8 + 8;
+                case 0x461b8:
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x461f4;
+                        continue;
+                    }
+                    r3 = r29 + 1206;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 1;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r3 = r3 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46f60;
+                        run_46e00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x461f4:
+                    r3 = readPages[(r29+1224)>>>12][((r29+1224)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46238;
+                        run_46200(); return;
+                    }
+                case 0x46200:
+                    pc=0x46200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_46200() throws ExecutionException { /* 0x46200 - 0x46400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x46200:
+                    r3 = r29 + 1204;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 2;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r2 = r2 + 2;
+                    r3 = r3 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46f34;
+                        run_46e00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x46238:
+                    r4 = readPages[(r29+1228)>>>12][((r29+1228)>>>2)&0x3ff];
+                    r3 = r0 + 128;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46dcc;
+                        run_46c00(); return;
+                    }
+                case 0x46248:
+                    r3 = readPages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff];
+                    r20 = r30 - r3;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46318;
+                        continue;
+                    }
+                    r3 = r20 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4770c;
+                        run_47600(); return;
+                    }
+                    r5 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r5 + 1024;
+                    r30 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x46294;
+                    continue;
+                case 0x46280:
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x462f0;
+                        continue;
+                    }
+                case 0x46294:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46280;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x462cc;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x462cc:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46294;
+                        continue;
+                    }
+                case 0x462f0:
+                    r3 = r3 + 1;
+                    r2 = r2 + r20;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46f08;
+                        run_46e00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x46318:
+                    r3 = r17 & 256;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46c64;
+                        run_46c00(); return;
+                    }
+                    r3 = readPages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    r2 = r2 + r3;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    r3 = r3 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46b68;
+                        run_46a00(); return;
+                    }
+                case 0x46350:
+                    r8 = r8 + 8;
+                case 0x46354:
+                    r17 = r17 & 4;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46450;
+                        run_46400(); return;
+                    }
+                    r3 = readPages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff];
+                    r4 = readPages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff];
+                    r16 = r3 - r4;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46450;
+                        run_46400(); return;
+                    }
+                    r3 = r16 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47ae8;
+                        run_47a00(); return;
+                    }
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    writePages[(r29+1244)>>>12][((r29+1244)>>>2)&0x3ff] = r19;
+                    r17 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x463ac;
+                    continue;
+                case 0x46398:
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46408;
+                        run_46400(); return;
+                    }
+                case 0x463ac:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r6 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r19;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r17;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46398;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x463e4;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x463e4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                case 0x46400:
+                    pc=0x46400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_46400() throws ExecutionException { /* 0x46400 - 0x46600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x46400:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x463ac;
+                        run_46200(); return;
+                    }
+                case 0x46408:
+                    r3 = r3 + 1;
+                    r5 = readPages[(r29+1244)>>>12][((r29+1244)>>>2)&0x3ff];
+                    r2 = r2 + r16;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r5;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r16;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46450;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46444;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46444:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                case 0x46450:
+                    r3 = readPages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff];
+                    r4 = r3 < r5 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4646c;
+                        continue;
+                    }
+                    r3 = r5 + r0;
+                case 0x4646c:
+                    r4 = readPages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff];
+                    r4 = r4 + r3;
+                    writePages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff] = r4;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46b94;
+                        run_46a00(); return;
+                    }
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r0;
+                    r8 = r29 + 40;
+                case 0x4648c:
+                    r3 = readPages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45d24;
+                        run_45c00(); return;
+                    }
+                case 0x464a4:
+                    r16 = readPages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x45db0;
+                    run_45c00(); return;
+                case 0x464b0:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45e1c;
+                        run_45e00(); return;
+                    }
+                    r5 = r0 + 32;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x464c8:
+                    r17 = r17 | 1;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x464d8:
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r4 = r3 + 1;
+                    if(r18 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47efc;
+                        run_47e00(); return;
+                    }
+                    r2 = r18 + -48;
+                    r3 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    r30 = r0 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4652c;
+                        continue;
+                    }
+                case 0x464fc:
+                    r4 = r4 + 1;
+                    r3 = r30 << 1;
+                    addr=r4+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r30 = r30 << 3;
+                    r30 = r3 + r30;
+                    r30 = r2 + r30;
+                    r2 = r18 + -48;
+                    r3 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x464fc;
+                        continue;
+                    }
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x478d8;
+                        run_47800(); return;
+                    }
+                case 0x4652c:
+                    r3 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de8;
+                    run_45c00(); return;
+                case 0x46538:
+                    r17 = r17 | 16;
+                    r2 = r17 & 16;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4698c;
+                        run_46800(); return;
+                    }
+                case 0x46550:
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                case 0x4656c:
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4657c;
+                        continue;
+                    }
+                    r5 = r0 + -129;
+                    r17 = r17 & r5;
+                case 0x4657c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46bc0;
+                        run_46a00(); return;
+                    }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46bc0;
+                        run_46a00(); return;
+                    }
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46fb4;
+                        run_46e00(); return;
+                    }
+                    r2 = r17 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46fb4;
+                        run_46e00(); return;
+                    }
+                    r2 = r0 + 48;
+                    addr=r29+1103;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 1;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r2;
+                    r16 = r29 + 1103;
+                case 0x465b4:
+                    r2 = readPages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff];
+                    r4 = r2 < r30 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x465cc;
+                        continue;
+                    }
+                    r2 = r30 + r0;
+                case 0x465cc:
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x46094;
+                    run_46000(); return;
+                case 0x465dc:
+                    r17 = r17 | 16;
+                    r2 = r17 & 16;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x469d0;
+                        run_46800(); return;
+                    }
+                case 0x465f4:
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                case 0x46600:
+                    pc=0x46600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_46600() throws ExecutionException { /* 0x46600 - 0x46800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x46600:
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x46618:
+                    r7 = r0 + r0;
+                    r2 = r18 + -48;
+                case 0x46620:
+                    r3 = r3 + 1;
+                    r4 = r7 << 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r18 = tmp;
+                    r7 = r7 << 3;
+                    r7 = r4 + r7;
+                    r7 = r7 + r2;
+                    r2 = r18 + -48;
+                    r4 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46620;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x45de8;
+                    run_45c00(); return;
+                case 0x46650:
+                    r2 = r17 & 16;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x468bc;
+                        run_46800(); return;
+                    }
+                case 0x46668:
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                case 0x4667c:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47434;
+                        run_47400(); return;
+                    }
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x46694:
+                    r17 = r17 | 64;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x466a4:
+                    r17 = r17 | 128;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x466b4:
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r0 + 48;
+                    addr=r29+1204;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + 120;
+                    addr=r29+1205;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r17 = r17 | 2;
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    r3 = 7 << 16;
+                    r3 = r3 + 248;
+                    writePages[(r29+1264)>>>12][((r29+1264)>>>2)&0x3ff] = r3;
+                    r4 = r0 + 2;
+                    r18 = r0 + 120;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x46708:
+                    r2 = r17 & 8;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47668;
+                        run_47600(); return;
+                    }
+                    r4 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r3 = r4 + 7;
+                case 0x4672c:
+                    r2 = r0 + -8;
+                    r2 = r3 & r2;
+                    r3 = r2 + 8;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    f0 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f1 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff] = r8;
+                    writePages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff] = f0;
+                    f12 = readPages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff];
+                    writePages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff] = f1;
+                    f13 = readPages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x46764;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x46764:
+                    r3 = r0 + 1;
+                    r8 = readPages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff];
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47450;
+                        run_47400(); return;
+                    }
+                    f0 = r0;
+                    f2 = readPages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47b44;
+                        run_47a00(); return;
+                    }
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                case 0x4679c:
+                    r2 = r18 < 72 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x478c8;
+                        run_47800(); return;
+                    }
+                    r16 = 7 << 16;
+                    r16 = r16 + 212;
+                case 0x467b0:
+                    r2 = r0 + -129;
+                    r17 = r17 & r2;
+                    r4 = r0 + 3;
+                    r2 = r0 + 3;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r4;
+                    r30 = r0 + r0;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x46094;
+                    run_46000(); return;
+                case 0x467d8:
+                    r17 = r17 | 8;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x467e8:
+                    r2 = 7 << 16;
+                    r2 = r2 + 228;
+                    writePages[(r29+1264)>>>12][((r29+1264)>>>2)&0x3ff] = r2;
+                    r2 = r17 & 16;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                case 0x46800:
+                    pc=0x46800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_46800() throws ExecutionException { /* 0x46800 - 0x46a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x46800:
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46904;
+                        continue;
+                    }
+                case 0x4680c:
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                case 0x46820:
+                    r3 = r17 & 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46fc4;
+                        run_46e00(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46fc4;
+                        run_46e00(); return;
+                    }
+                    r3 = r0 + 48;
+                    addr=r29+1204;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+1205;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r17 = r17 | 2;
+                    r4 = r0 + 2;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x46858:
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    addr=r29+1064;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                case 0x46878:
+                    r4 = r0 + 1;
+                    r5 = r0 + 1;
+                    r3 = r0 + r0;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r4;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r5;
+                    r30 = r0 + r0;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                    r16 = r29 + 1064;
+                    /* Next insn is delay slot */ 
+                    pc=0x460ac;
+                    run_46000(); return;
+                case 0x468a0:
+                    r17 = r17 | 16;
+                    r2 = r17 & 16;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46668;
+                        run_46600(); return;
+                    }
+                case 0x468bc:
+                    r2 = r17 & 64;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4769c;
+                        run_47600(); return;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x4667c;
+                    run_46600(); return;
+                case 0x468e0:
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    r3 = 7 << 16;
+                    r3 = r3 + 248;
+                    r2 = r17 & 16;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1264)>>>12][((r29+1264)>>>2)&0x3ff] = r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4680c;
+                        continue;
+                    }
+                case 0x46904:
+                    r2 = r17 & 64;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47654;
+                        run_47600(); return;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x46820;
+                    continue;
+                case 0x46928:
+                    r2 = r17 & 16;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a34;
+                        run_46a00(); return;
+                    }
+                    r17 = r17 & 64;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a34;
+                        run_46a00(); return;
+                    }
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x45d0c;
+                    run_45c00(); return;
+                case 0x46978:
+                    r2 = r17 & 16;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46550;
+                        run_46400(); return;
+                    }
+                case 0x4698c:
+                    r2 = r17 & 64;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4767c;
+                        run_47600(); return;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    r4 = r0 + r0;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x469bc:
+                    r2 = r17 & 16;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x465f4;
+                        run_46400(); return;
+                    }
+                case 0x469d0:
+                    r2 = r17 & 64;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x476b0;
+                        run_47600(); return;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    r4 = r0 + 1;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x46a00:
+                    pc=0x46a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_46a00() throws ExecutionException { /* 0x46a00 - 0x46c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x46a00:
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r2;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x46a10:
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1336)>>>12][((r29+1336)>>>2)&0x3ff] = r3;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fa8;
+                        run_45e00(); return;
+                    }
+                    addr=r29+1064;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x46878;
+                    run_46800(); return;
+                case 0x46a34:
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x45d0c;
+                    run_45c00(); return;
+                case 0x46a64:
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x461b8;
+                    run_46000(); return;
+                case 0x46a70:
+                    r4 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r2 = r2 + 1;
+                    r3 = r4 < 2 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46eb0;
+                        run_46e00(); return;
+                    }
+                case 0x46a94:
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4738c;
+                        run_47200(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x46ab4:
+                    r4 = readPages[(r29+1256)>>>12][((r29+1256)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r5 = readPages[(r29+1236)>>>12][((r29+1236)>>>2)&0x3ff];
+                    r2 = r2 + r4;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x473bc;
+                        run_47200(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x46ae4:
+                    f0 = r0;
+                    f2 = readPages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47114;
+                        run_47000(); return;
+                    }
+                    r5 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r16 = r16 + 1;
+                    r4 = r5 + -1;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r2 = r2 + r4;
+                case 0x46b20:
+                    r3 = r3 + 1;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46ed8;
+                        run_46e00(); return;
+                    }
+                case 0x46b38:
+                    r8 = r8 + 8;
+                case 0x46b3c:
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r4 = r29 + 1188;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r4;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r5;
+                    r2 = r5 + r2;
+                case 0x46b50:
+                    r3 = r3 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46350;
+                        run_46200(); return;
+                    }
+                case 0x46b68:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46b7c;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46b7c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46354;
+                    run_46200(); return;
+                case 0x46b94:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46ba8;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46ba8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r0;
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x4648c;
+                    run_46400(); return;
+                case 0x46bc0:
+                    r5 = r0 + 1;
+                    if(r4 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46f8c;
+                        run_46e00(); return;
+                    }
+                    r6 = r29 + 1104;
+                    r5 = r0 + 2;
+                    r16 = r6 + r0;
+                    if(r4 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46c14;
+                        run_46c00(); return;
+                    }
+                    r5 = readPages[(r29+1264)>>>12][((r29+1264)>>>2)&0x3ff];
+                case 0x46be4:
+                    r4 = r2 & 15;
+                    r4 = r5 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r16 = r16 + -1;
+                    r2 = r2 >>> 4;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46be4;
+                        continue;
+                    }
+                case 0x46c00:
+                    pc=0x46c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_46c00() throws ExecutionException { /* 0x46c00 - 0x46e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x46c00:
+                case 0x46c04:
+                    r6 = r6 - r16;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x465b4;
+                    run_46400(); return;
+                case 0x46c14:
+                    r4 = r2 & 7;
+                    r16 = r16 + -1;
+                    r4 = r4 + 48;
+                    r2 = r2 >>> 3;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46c14;
+                        continue;
+                    }
+                    r2 = r17 & 1;
+                    r5 = r16 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46c04;
+                        continue;
+                    }
+                    r2 = r0 + 48;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46c04;
+                        continue;
+                    }
+                    r16 = r16 + -1;
+                    r6 = r6 - r16;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x465b4;
+                    run_46400(); return;
+                case 0x46c64:
+                    r18 = r18 < 102 ? 1 : 0;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a70;
+                        run_46a00(); return;
+                    }
+                    f0 = r0;
+                    f2 = readPages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46fd8;
+                        run_46e00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r3 = r3 + 276;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 1;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r3 = r3 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47720;
+                        run_47600(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x46ccc:
+                    r3 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r4 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r3 = r3 < r4 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46cf0;
+                        continue;
+                    }
+                    r3 = r17 & 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46354;
+                        run_46200(); return;
+                    }
+                case 0x46cf0:
+                    r3 = readPages[(r29+1236)>>>12][((r29+1236)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1256)>>>12][((r29+1256)>>>2)&0x3ff];
+                    r2 = r2 + r3;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    r3 = r3 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47918;
+                        run_47800(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x46d2c:
+                    r3 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r16 = r3 + -1;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46354;
+                        run_46200(); return;
+                    }
+                    r3 = r16 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x471b0;
+                        run_47000(); return;
+                    }
+                    r5 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r5 + 1024;
+                    r18 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x46d78;
+                    continue;
+                case 0x46d64:
+                    r8 = r8 + 8;
+                case 0x46d68:
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x471bc;
+                        run_47000(); return;
+                    }
+                case 0x46d78:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46d64;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46db0;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46db0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46d68;
+                    continue;
+                case 0x46dcc:
+                    r3 = readPages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff];
+                    r4 = readPages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff];
+                    r20 = r3 - r4;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46248;
+                        run_46200(); return;
+                    }
+                    r3 = r20 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47bb8;
+                        run_47a00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r4 + 1024;
+                    r7 = r0 + 16;
+                case 0x46e00:
+                    pc=0x46e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_46e00() throws ExecutionException { /* 0x46e00 - 0x47000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x46e00:
+                    /* Next insn is delay slot */ 
+                    pc=0x46e1c;
+                    continue;
+                case 0x46e08:
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r8 = r8 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46e80;
+                        continue;
+                    }
+                case 0x46e1c:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r7;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46e08;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    writePages[(r29+1280)>>>12][((r29+1280)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x46e58;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46e58:
+                    r7 = readPages[(r29+1280)>>>12][((r29+1280)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46e1c;
+                        continue;
+                    }
+                case 0x46e80:
+                    r3 = r3 + 1;
+                    r2 = r2 + r20;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47408;
+                        run_47400(); return;
+                    }
+                    r8 = r8 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x46248;
+                    run_46200(); return;
+                case 0x46eb0:
+                    r3 = r17 & 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a94;
+                        run_46a00(); return;
+                    }
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46b38;
+                        run_46a00(); return;
+                    }
+                case 0x46ed8:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46eec;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46eec:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46b3c;
+                    run_46a00(); return;
+                case 0x46f08:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46f1c;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46f1c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46318;
+                    run_46200(); return;
+                case 0x46f34:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46f48;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46f48:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46238;
+                    run_46200(); return;
+                case 0x46f60:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x46f74;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x46f74:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x461f4;
+                    run_46000(); return;
+                case 0x46f8c:
+                    r4 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x471d0;
+                        run_47000(); return;
+                    }
+                    r2 = r2 + 48;
+                    r4 = r0 + 1;
+                    addr=r29+1103;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r4;
+                    r16 = r29 + 1103;
+                    /* Next insn is delay slot */ 
+                    pc=0x465b4;
+                    run_46400(); return;
+                case 0x46fb4:
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r0;
+                    r16 = r29 + 1104;
+                    /* Next insn is delay slot */ 
+                    pc=0x465b4;
+                    run_46400(); return;
+                case 0x46fc4:
+                    r4 = r0 + 2;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x46fd8:
+                    r3 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4774c;
+                        run_47600(); return;
+                    }
+                    r3 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r4 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    r18 = r16 + r3;
+                    r20 = r18 - r16;
+                    r3 = r4 < r20 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47008;
+                        run_47000(); return;
+                    }
+                case 0x47000:
+                    pc=0x47000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_47000() throws ExecutionException { /* 0x47000 - 0x47200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x47000:
+                    r20 = r4 + r0;
+                case 0x47008:
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4703c;
+                        continue;
+                    }
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r2 = r2 + r20;
+                    r3 = r3 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x479cc;
+                        run_47800(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x4703c:
+                    if(r20 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x479c0;
+                        run_47800(); return;
+                    }
+                case 0x47044:
+                    r3 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    r20 = r3 - r20;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47238;
+                        run_47200(); return;
+                    }
+                    r3 = r20 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x476d0;
+                        run_47600(); return;
+                    }
+                    r5 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r5 + 1024;
+                    r30 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x47090;
+                    continue;
+                case 0x4707c:
+                    r8 = r8 + 8;
+                case 0x47080:
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x476dc;
+                        run_47600(); return;
+                    }
+                case 0x47090:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4707c;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x470c8;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x470c8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x47080;
+                    continue;
+                case 0x470e4:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x470f8;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x470f8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x461b8;
+                    run_46000(); return;
+                case 0x47114:
+                    r4 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r16 = r4 + -1;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46b3c;
+                        run_46a00(); return;
+                    }
+                    r4 = r16 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x473ec;
+                        run_47200(); return;
+                    }
+                    r4 = 7 << 16;
+                    r23 = r4 + 1024;
+                    r18 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x4715c;
+                    continue;
+                case 0x47148:
+                    r8 = r8 + 8;
+                case 0x4714c:
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x473f4;
+                        run_47200(); return;
+                    }
+                case 0x4715c:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47148;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47194;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47194:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x4714c;
+                    continue;
+                case 0x471b0:
+                    r4 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r4 + 1024;
+                case 0x471bc:
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r16;
+                    r2 = r2 + r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x46b50;
+                    run_46a00(); return;
+                case 0x471d0:
+                    r6 = r29 + 1104;
+                    r16 = r6 + r0;
+                    r4 = r0 + 10;
+                case 0x471dc:
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r4!=0) {
+                        hi = (int)((r2 & 0xffffffffL) % (r4 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r4 & 0xffffffffL));
+                        }
+                        pc=0x471e8;
+                        continue;
+                    }
+                    if(r4!=0) {
+                    hi = (int)((r2 & 0xffffffffL) % (r4 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r4 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x471e8:
+                    r16 = r16 + -1;
+                    r5 = hi;
+                    r5 = r5 + 48;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = lo;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x471dc;
+                        continue;
+                    }
+                case 0x47200:
+                    pc=0x47200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_47200() throws ExecutionException { /* 0x47200 - 0x47400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x47200:
+                    r6 = r6 - r16;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x465b4;
+                    run_46400(); return;
+                case 0x47214:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47228;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47228:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                case 0x47238:
+                    r3 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r16 = r16 + r3;
+                    r3 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r4 = r3 < r5 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47264;
+                        continue;
+                    }
+                    r4 = r17 & 1;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47298;
+                        continue;
+                    }
+                case 0x47264:
+                    r4 = readPages[(r29+1236)>>>12][((r29+1236)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1256)>>>12][((r29+1256)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r2 = r2 + r5;
+                    r4 = r4 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r4;
+                    r4 = r4 < 8 ? 1 : 0;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x479f8;
+                        run_47800(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x47298:
+                    r4 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r18 = r18 - r16;
+                    r3 = r4 - r3;
+                    r4 = r18 < r3 ? 1 : 0;
+                    r20 = r3 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x472b8;
+                        continue;
+                    }
+                    r20 = r18 + r0;
+                case 0x472b8:
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x472ec;
+                        continue;
+                    }
+                    r4 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r2 = r2 + r20;
+                    r4 = r4 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r4;
+                    r4 = r4 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47a6c;
+                        run_47a00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x472ec:
+                    if(r20 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47a60;
+                        run_47a00(); return;
+                    }
+                case 0x472f4:
+                    r16 = r3 - r20;
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46354;
+                        run_46200(); return;
+                    }
+                    r3 = r16 < 17 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x471b0;
+                        run_47000(); return;
+                    }
+                    r5 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r5 + 1024;
+                    r18 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x47338;
+                    continue;
+                case 0x47324:
+                    r8 = r8 + 8;
+                case 0x47328:
+                    r16 = r16 + -16;
+                    r4 = r16 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x471bc;
+                        run_47000(); return;
+                    }
+                case 0x47338:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47324;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47370;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47370:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x47328;
+                    continue;
+                case 0x4738c:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x473a0;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x473a0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46ab4;
+                    run_46a00(); return;
+                case 0x473bc:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x473d0;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x473d0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46ae4;
+                    run_46a00(); return;
+                case 0x473ec:
+                    r5 = 7 << 16;
+                    r23 = r5 + 1024;
+                case 0x473f4:
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r16;
+                    r2 = r2 + r16;
+                case 0x47400:
+                    pc=0x47400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_47400() throws ExecutionException { /* 0x47400 - 0x47600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x47400:
+                    /* Next insn is delay slot */ 
+                    pc=0x46b20;
+                    run_46a00(); return;
+                case 0x47408:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x4741c;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x4741c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46248;
+                    run_46200(); return;
+                case 0x47434:
+                    r3 = r0 + 45;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 - r2;
+                    r3 = r0 + 45;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x47450:
+                    f12 = readPages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff];
+                    writePages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff] = r8;
+                    f13 = readPages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x47464;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x47464:
+                    r8 = readPages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47888;
+                        run_47800(); return;
+                    }
+                    r9 = r0 + -33;
+                    r2 = r0 + -1;
+                    r20 = r18 & r9;
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47df4;
+                        run_47c00(); return;
+                    }
+                    r2 = r0 + 71;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47d14;
+                        run_47c00(); return;
+                    }
+                case 0x47490:
+                    r2 = readPages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff];
+                    r23 = r17 | 256;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47d68;
+                        run_47c00(); return;
+                    }
+                    f0 = readPages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff];
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r0;
+                    f1 = readPages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff];
+                    writePages[(r29+1276)>>>12][((r29+1276)>>>2)&0x3ff] = f0;
+                    writePages[(r29+1272)>>>12][((r29+1272)>>>2)&0x3ff] = f1;
+                case 0x474b8:
+                    r2 = r0 + 102;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47b68;
+                        run_47a00(); return;
+                    }
+                    r2 = r0 + 70;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47b68;
+                        run_47a00(); return;
+                    }
+                    r2 = r0 + 69;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47d5c;
+                        run_47c00(); return;
+                    }
+                    r5 = r30 + r0;
+                case 0x474e0:
+                    r2 = r0 + 2;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 1200;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 1196;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    r7 = readPages[(r29+1276)>>>12][((r29+1276)>>>2)&0x3ff];
+                    r2 = r29 + 1180;
+                    r6 = readPages[(r29+1272)>>>12][((r29+1272)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r4 = r21 + r0;
+                    writePages[(r29+1280)>>>12][((r29+1280)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x47520;
+                    pc=0x57400;
+                    run_57400(); return;
+                case 0x47520:
+                    r16 = r2 + r0;
+                    r2 = r0 + 103;
+                    r5 = readPages[(r29+1280)>>>12][((r29+1280)>>>2)&0x3ff];
+                    r8 = readPages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff];
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47544;
+                        continue;
+                    }
+                    r2 = r0 + 71;
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47550;
+                        continue;
+                    }
+                case 0x47544:
+                    r2 = r17 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47e00;
+                        run_47e00(); return;
+                    }
+                case 0x47550:
+                    r2 = r0 + 70;
+                    r4 = r16 + r5;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47bd8;
+                        run_47a00(); return;
+                    }
+                case 0x47560:
+                    f0 = r0;
+                    f2 = readPages[(r29+1276)>>>12][((r29+1276)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+1272)>>>12][((r29+1272)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47bcc;
+                        run_47a00(); return;
+                    }
+                    r2 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                    r3 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x475bc;
+                        continue;
+                    }
+                    r5 = r0 + 48;
+                case 0x4759c:
+                    r3 = r2 + 1;
+                    writePages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff] = r3;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                    r3 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4759c;
+                        continue;
+                    }
+                case 0x475bc:
+                    r2 = r2 - r16;
+                    writePages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 71;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47b18;
+                        run_47a00(); return;
+                    }
+                    r2 = r18 < 102 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47fa0;
+                        run_47e00(); return;
+                    }
+                    r3 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r2 = r0 + 102;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r3;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47e0c;
+                        run_47e00(); return;
+                    }
+                case 0x475f0:
+                    r3 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r4 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    r2 = r4 < r3 ? 1 : 0;
+                case 0x47600:
+                    pc=0x47600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_47600() throws ExecutionException { /* 0x47600 - 0x47800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x47600:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47d90;
+                        run_47c00(); return;
+                    }
+                    r17 = r17 & 1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47dc8;
+                        run_47c00(); return;
+                    }
+                    r2 = r4 + r0;
+                    if(r4 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47fbc;
+                        run_47e00(); return;
+                    }
+                case 0x47620:
+                    r3 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    r18 = r0 + 103;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r3;
+                case 0x4762c:
+                    r5 = readPages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff];
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47af8;
+                        run_47a00(); return;
+                    }
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r2;
+                    r17 = r23 + r0;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x46094;
+                    run_46000(); return;
+                case 0x47654:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x46820;
+                    run_46800(); return;
+                case 0x47668:
+                    r2 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r3 = r2 + 7;
+                    /* Next insn is delay slot */ 
+                    pc=0x4672c;
+                    run_46600(); return;
+                case 0x4767c:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    r4 = r0 + r0;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x4769c:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x4667c;
+                    run_46600(); return;
+                case 0x476b0:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r3;
+                    r4 = r0 + 1;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4656c;
+                    run_46400(); return;
+                case 0x476d0:
+                    r4 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r4 + 1024;
+                case 0x476dc:
+                    r3 = r3 + 1;
+                    r2 = r2 + r20;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    r3 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47214;
+                        run_47200(); return;
+                    }
+                    r8 = r8 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x47238;
+                    run_47200(); return;
+                case 0x4770c:
+                    r4 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r4 + 1024;
+                    /* Next insn is delay slot */ 
+                    pc=0x462f0;
+                    run_46200(); return;
+                case 0x47720:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47734;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47734:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46ccc;
+                    run_46c00(); return;
+                case 0x4774c:
+                    r4 = 7 << 16;
+                    r4 = r4 + 276;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r4;
+                    r4 = r0 + 1;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r4 = r4 + 1;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r4;
+                    r4 = r4 < 8 ? 1 : 0;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x478e8;
+                        run_47800(); return;
+                    }
+                    r8 = r8 + 8;
+                    r18 = r3 + r0;
+                case 0x47788:
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x477ac;
+                        continue;
+                    }
+                    r3 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x477ac;
+                        continue;
+                    }
+                    r3 = r17 & 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46354;
+                        run_46200(); return;
+                    }
+                case 0x477ac:
+                    r3 = readPages[(r29+1236)>>>12][((r29+1236)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1256)>>>12][((r29+1256)>>>2)&0x3ff];
+                    r2 = r2 + r3;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    r3 = r3 + 1;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47d28;
+                        run_47c00(); return;
+                    }
+                    r8 = r8 + 8;
+                case 0x477e8:
+                    r18 = r0 - r18;
+                    if(r18 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4796c;
+                        run_47800(); return;
+                    }
+                    r4 = r18 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47a28;
+                        run_47a00(); return;
+                    }
+                case 0x47800:
+                    pc=0x47800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_47800() throws ExecutionException { /* 0x47800 - 0x47a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x47800:
+                    r5 = 7 << 16;
+                    r23 = r5 + 1024;
+                    r20 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x47828;
+                    continue;
+                case 0x47814:
+                    r8 = r8 + 8;
+                case 0x47818:
+                    r18 = r18 + -16;
+                    r4 = r18 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47a30;
+                        run_47a00(); return;
+                    }
+                case 0x47828:
+                    r3 = r3 + 1;
+                    r2 = r2 + 16;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47814;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47860;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47860:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x47818;
+                    continue;
+                case 0x4787c:
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r30;
+                    /* Next insn is delay slot */ 
+                    pc=0x46070;
+                    run_46000(); return;
+                case 0x47888:
+                    r2 = r18 < 72 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47b58;
+                        run_47a00(); return;
+                    }
+                    r16 = 7 << 16;
+                    r16 = r16 + 220;
+                case 0x4789c:
+                    r2 = r0 + -129;
+                    r17 = r17 & r2;
+                    r5 = r0 + 3;
+                    r2 = r0 + 3;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r2;
+                    r30 = r0 + r0;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x46094;
+                    run_46000(); return;
+                case 0x478c8:
+                    r16 = 7 << 16;
+                    r16 = r16 + 216;
+                    /* Next insn is delay slot */ 
+                    pc=0x467b0;
+                    run_46600(); return;
+                case 0x478d8:
+                    r30 = r0 + -1;
+                    r3 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de8;
+                    run_45c00(); return;
+                case 0x478e8:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x478fc;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x478fc:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r18 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x47788;
+                    run_47600(); return;
+                case 0x47918:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x4792c;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x4792c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x46d2c;
+                    run_46c00(); return;
+                case 0x47944:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47958;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47958:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                case 0x4796c:
+                    r4 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r16;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r4;
+                    r2 = r4 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x46b50;
+                    run_46a00(); return;
+                case 0x47984:
+                    writePages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x47990;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x47990:
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r2;
+                    r8 = readPages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff];
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46080;
+                        run_46000(); return;
+                    }
+                case 0x479a0:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x46080;
+                    run_46000(); return;
+                case 0x479ac:
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    writePages[(r29+1244)>>>12][((r29+1244)>>>2)&0x3ff] = r19;
+                    /* Next insn is delay slot */ 
+                    pc=0x46188;
+                    run_46000(); return;
+                case 0x479c0:
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x47044;
+                    run_47000(); return;
+                case 0x479cc:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x479e0;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x479e0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x4703c;
+                    run_47000(); return;
+                case 0x479f8:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                case 0x47a00:
+                    pc=0x47a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_47a00() throws ExecutionException { /* 0x47a00 - 0x47c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x47a00:
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47a0c;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47a0c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r3 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x47298;
+                    run_47200(); return;
+                case 0x47a28:
+                    r4 = 7 << 16;
+                    r23 = r4 + 1024;
+                case 0x47a30:
+                    r3 = r3 + 1;
+                    r2 = r2 + r18;
+                    r4 = r3 < 8 ? 1 : 0;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r23;
+                    writePages[(r8+4)>>>12][((r8+4)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r3;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47944;
+                        run_47800(); return;
+                    }
+                    r8 = r8 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x4796c;
+                    run_47800(); return;
+                case 0x47a60:
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x472f4;
+                    run_47200(); return;
+                case 0x47a6c:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47a80;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47a80:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r3 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = r5 - r3;
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x472ec;
+                    run_47200(); return;
+                case 0x47aa4:
+                    r3 = (r30&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r2 = r30 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47ab8;
+                        continue;
+                    }
+                    r2 = r0 + 6;
+                case 0x47ab8:
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47ef0;
+                        run_47e00(); return;
+                    }
+                case 0x47ac4:
+                    r16 = 7 << 16;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r20;
+                    r3 = r0 + r0;
+                    r30 = r0 + r0;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                    r16 = r16 + 268;
+                    /* Next insn is delay slot */ 
+                    pc=0x460ac;
+                    run_46000(); return;
+                case 0x47ae8:
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    writePages[(r29+1244)>>>12][((r29+1244)>>>2)&0x3ff] = r19;
+                    /* Next insn is delay slot */ 
+                    pc=0x46408;
+                    run_46400(); return;
+                case 0x47af8:
+                    r3 = r0 + 45;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r2;
+                    r17 = r23 + r0;
+                    r3 = r0 + 45;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4609c;
+                    run_46000(); return;
+                case 0x47b18:
+                    r2 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r3 = r2 < -3 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47c58;
+                        run_47c00(); return;
+                    }
+                    r3 = r30 < r2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47c58;
+                        run_47c00(); return;
+                    }
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x475f0;
+                    run_47400(); return;
+                case 0x47b44:
+                    r2 = r0 + 45;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r0 + 45;
+                    /* Next insn is delay slot */ 
+                    pc=0x4679c;
+                    run_46600(); return;
+                case 0x47b58:
+                    r16 = 7 << 16;
+                    r16 = r16 + 224;
+                    /* Next insn is delay slot */ 
+                    pc=0x4789c;
+                    run_47800(); return;
+                case 0x47b68:
+                    r2 = r0 + 3;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 1200;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 1196;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r2;
+                    r7 = readPages[(r29+1276)>>>12][((r29+1276)>>>2)&0x3ff];
+                    r2 = r29 + 1180;
+                    r6 = readPages[(r29+1272)>>>12][((r29+1272)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r30;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r4 = r21 + r0;
+                    writePages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x47ba4;
+                    pc=0x57400;
+                    run_57400(); return;
+                case 0x47ba4:
+                    r16 = r2 + r0;
+                    r5 = r30 + r0;
+                    r8 = readPages[(r29+1284)>>>12][((r29+1284)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x47550;
+                    run_47400(); return;
+                case 0x47bb8:
+                    r5 = 7 << 16;
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r23 = r5 + 1024;
+                    /* Next insn is delay slot */ 
+                    pc=0x46e80;
+                    run_46e00(); return;
+                case 0x47bcc:
+                    r2 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x475bc;
+                    run_47400(); return;
+                case 0x47bd8:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 48;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47bfc;
+                        continue;
+                    }
+                case 0x47be8:
+                    r2 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r4 = r4 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x47560;
+                    run_47400(); return;
+                case 0x47bfc:
+                    f0 = r0;
+                case 0x47c00:
+                    pc=0x47c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_47c00() throws ExecutionException { /* 0x47c00 - 0x47e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x47c00:
+                    f2 = readPages[(r29+1276)>>>12][((r29+1276)>>>2)&0x3ff];
+                    f1 = r0;
+                    f3 = readPages[(r29+1272)>>>12][((r29+1272)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47be8;
+                        run_47a00(); return;
+                    }
+                    r2 = r0 + 1;
+                    r2 = r2 - r5;
+                    writePages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff] = r2;
+                    r4 = r4 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x47560;
+                    run_47400(); return;
+                case 0x47c38:
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r30;
+                    addr=r29+1206;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r20;
+                    r30 = r0 + r0;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x46094;
+                    run_46000(); return;
+                case 0x47c58:
+                    r18 = r18 + -2;
+                case 0x47c5c:
+                    r2 = r2 + -1;
+                    writePages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff] = r2;
+                    addr=r29+1188;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47f3c;
+                        run_47e00(); return;
+                    }
+                    r3 = r0 + 43;
+                    addr=r29+1189;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x47c78:
+                    r3 = r2 < 10 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47e38;
+                        run_47e00(); return;
+                    }
+                    r2 = r2 + 48;
+                    r3 = r0 + 48;
+                    addr=r29+1191;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+1190;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r29 + 1192;
+                    r4 = r29 + 1188;
+                case 0x47c9c:
+                    r3 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r4 = r2 - r4;
+                    r3 = r3 + r4;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r4;
+                    r2 = r3 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47ce8;
+                        continue;
+                    }
+                case 0x47cc0:
+                    r3 = readPages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r3;
+                    r2 = r3 + r0;
+                    if(r3 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47d04;
+                        continue;
+                    }
+                case 0x47cdc:
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4762c;
+                    run_47600(); return;
+                case 0x47ce8:
+                    r17 = r17 & 1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47cc0;
+                        continue;
+                    }
+                    r2 = readPages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff];
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47cdc;
+                        continue;
+                    }
+                case 0x47d04:
+                    r2 = r0 + r0;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4762c;
+                    run_47600(); return;
+                case 0x47d14:
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47490;
+                        run_47400(); return;
+                    }
+                    r30 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x47490;
+                    run_47400(); return;
+                case 0x47d28:
+                    r4 = r21 + r0;
+                    r5 = r22 + r0;
+                    r6 = r29 + 1168;
+                    /* Next insn is delay slot */ 
+                    r31=0x47d3c;
+                    pc=0x63400;
+                    run_63400(); return;
+                case 0x47d3c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x45fcc;
+                        run_45e00(); return;
+                    }
+                    r18 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    r2 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r3 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r8 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x477e8;
+                    run_47600(); return;
+                case 0x47d5c:
+                    r5 = r30 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x474e0;
+                    run_47400(); return;
+                case 0x47d68:
+                    r3 = readPages[(r29+1248)>>>12][((r29+1248)>>>2)&0x3ff];
+                    r2 = 32768 << 16;
+                    r4 = readPages[(r29+1252)>>>12][((r29+1252)>>>2)&0x3ff];
+                    r2 = r3 ^ r2;
+                    r5 = r0 + 45;
+                    writePages[(r29+1272)>>>12][((r29+1272)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1276)>>>12][((r29+1276)>>>2)&0x3ff] = r4;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x474b8;
+                    run_47400(); return;
+                case 0x47d90:
+                    r3 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47f2c;
+                        run_47e00(); return;
+                    }
+                    r2 = r0 + 1;
+                case 0x47da4:
+                    r3 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r2 = r2 + r3;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r2;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47de4;
+                        continue;
+                    }
+                case 0x47dbc:
+                    r18 = r0 + 103;
+                    /* Next insn is delay slot */ 
+                    pc=0x4762c;
+                    run_47600(); return;
+                case 0x47dc8:
+                    r3 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r3;
+                    r2 = r3 + r0;
+                    if(r3 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47dbc;
+                        continue;
+                    }
+                case 0x47de4:
+                    r2 = r0 + r0;
+                    r18 = r0 + 103;
+                    /* Next insn is delay slot */ 
+                    pc=0x4762c;
+                    run_47600(); return;
+                case 0x47df4:
+                    r30 = r0 + 6;
+                    /* Next insn is delay slot */ 
+                    pc=0x47490;
+                    run_47400(); return;
+                case 0x47e00:
+                    pc=0x47e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_47e00() throws ExecutionException { /* 0x47e00 - 0x48000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x47e00:
+                    r2 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x475bc;
+                    run_47400(); return;
+                case 0x47e0c:
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47f50;
+                        continue;
+                    }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47ecc;
+                        continue;
+                    }
+                    r17 = r17 & 1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47ecc;
+                        continue;
+                    }
+                    r2 = r3 + r0;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x4762c;
+                    run_47600(); return;
+                case 0x47e38:
+                    r6 = r29 + 1187;
+                    r3 = r6 + r0;
+                    r4 = r0 + 10;
+                case 0x47e44:
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        hi = r2%r4; lo = r2/r4;
+                        pc=0x47e50;
+                        continue;
+                    }
+                    hi = r2%r4; lo = r2/r4;
+                    throw new ExecutionException("Break");
+                case 0x47e50:
+                    r3 = r3 + -1;
+                    r5 = hi;
+                    r5 = r5 + 48;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = lo;
+                    r5 = r2 < 10 ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47e44;
+                        continue;
+                    }
+                    r2 = r2 + 48;
+                    r5 = r2 << 24;
+                    r4 = r3 + -1;
+                    r5 = r5 >> 24;
+                    r2 = ((r4 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47fac;
+                        continue;
+                    }
+                    r2 = r29 + 1190;
+                    /* Next insn is delay slot */ 
+                    pc=0x47ea0;
+                    continue;
+                case 0x47e9c:
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                case 0x47ea0:
+                    r2 = r2 + 1;
+                    r4 = r4 + 1;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r4 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47e9c;
+                        continue;
+                    }
+                    r4 = r29 + 1188;
+                    r2 = r4 - r3;
+                    r3 = r29 + 1190;
+                    r2 = r3 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x47c9c;
+                    run_47c00(); return;
+                case 0x47ecc:
+                    r3 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    r2 = r30 + 1;
+                    r2 = r3 + r2;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r2;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4762c;
+                        run_47600(); return;
+                    }
+                case 0x47ee4:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4762c;
+                    run_47600(); return;
+                case 0x47ef0:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x47ac4;
+                    run_47a00(); return;
+                case 0x47efc:
+                    r3 = readPages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff];
+                    r30 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r2 = r3 + 4;
+                    r3 = r4 + r0;
+                    if(r30 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x46a00;
+                        run_46a00(); return;
+                    }
+                    writePages[(r29+1340)>>>12][((r29+1340)>>>2)&0x3ff] = r2;
+                    r30 = r0 + -1;
+                    r16 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45de0;
+                    run_45c00(); return;
+                case 0x47f2c:
+                    r2 = r0 + 2;
+                    r2 = r2 - r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x47da4;
+                    run_47c00(); return;
+                case 0x47f3c:
+                    r3 = r0 + 45;
+                    r2 = r0 - r2;
+                    addr=r29+1189;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x47c78;
+                    run_47c00(); return;
+                case 0x47f50:
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47f84;
+                        continue;
+                    }
+                    r17 = r17 & 1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x47f84;
+                        continue;
+                    }
+                    r3 = r0 + 1;
+                    r2 = r0 + 1;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x4762c;
+                    run_47600(); return;
+                case 0x47f78:
+                    r16 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x45f18;
+                    run_45e00(); return;
+                case 0x47f84:
+                    r30 = r30 + 2;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r30;
+                    r2 = r30 + r0;
+                    if(r30 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4762c;
+                        run_47600(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x47ee4;
+                    continue;
+                case 0x47fa0:
+                    r2 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x47c5c;
+                    run_47c00(); return;
+                case 0x47fac:
+                    r2 = r29 + 1190;
+                    r4 = r29 + 1188;
+                    /* Next insn is delay slot */ 
+                    pc=0x47c9c;
+                    run_47c00(); return;
+                case 0x47fbc:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x47620;
+                    run_47600(); return;
+                case 0x48000:
+                    pc=0x48000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_48000() throws ExecutionException { /* 0x48000 - 0x48200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x48000:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x45c00;
+                    run_45c00(); return;
+                case 0x48200:
+                    pc=0x48200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_48200() throws ExecutionException { /* 0x48200 - 0x48400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x48200:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    r18 = r5 + r0;
+                    r16 = r6 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48238;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x483e4;
+                        continue;
+                    }
+                case 0x48238:
+                    r2 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r3 = r2 & 65535;
+                    r4 = r3 & 8;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x483b8;
+                        continue;
+                    }
+                    r4 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x483b8;
+                        continue;
+                    }
+                case 0x4826c:
+                    r3 = r3 & 8192;
+                    r18 = r18 & 255;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x482f4;
+                        continue;
+                    }
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r4 = r3 - r4;
+                    r2 = r4 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48324;
+                        continue;
+                    }
+                case 0x48294:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    r2 = r3 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48368;
+                        continue;
+                    }
+                case 0x482c0:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4838c;
+                        continue;
+                    }
+                case 0x482d4:
+                    r2 = r18 + r0;
+                case 0x482d8:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x482f4:
+                    r3 = readPages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff];
+                    r2 = r2 | 8192;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -8193;
+                    r2 = r3 & r2;
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r4 = r3 - r4;
+                    r2 = r4 < r2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48294;
+                        continue;
+                    }
+                case 0x48324:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x48334;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x48334:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48380;
+                        continue;
+                    }
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    r2 = r3 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x482c0;
+                        continue;
+                    }
+                case 0x48368:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x48378;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x48378:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x482d4;
+                        continue;
+                    }
+                case 0x48380:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x482d8;
+                    continue;
+                case 0x4838c:
+                    r2 = r0 + 10;
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x482d4;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x483a8;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x483a8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x482d4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x48380;
+                    continue;
+                case 0x483b8:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x483c8;
+                    pc=0x48600;
+                    run_48600(); return;
+                case 0x483c8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48380;
+                        continue;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r4 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r3 = r2 & 65535;
+                    /* Next insn is delay slot */ 
+                    pc=0x4826c;
+                    continue;
+                case 0x483e4:
+                    /* Next insn is delay slot */ 
+                    r31=0x483ec;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x483ec:
+                    /* Next insn is delay slot */ 
+                    pc=0x48238;
+                    continue;
+                case 0x48400:
+                    pc=0x48400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_48400() throws ExecutionException { /* 0x48400 - 0x48600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x48400:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x48600:
+                    pc=0x48600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_48600() throws ExecutionException { /* 0x48600 - 0x48800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x48600:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r5 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48634;
+                        continue;
+                    }
+                    r3 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48744;
+                        continue;
+                    }
+                case 0x48634:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r6 = tmp;
+                    r2 = r6 & 65535;
+                    r3 = r2 & 8;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x486a4;
+                        continue;
+                    }
+                    r3 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x486d4;
+                        continue;
+                    }
+                case 0x4865c:
+                    r4 = r2 & 1;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48704;
+                        continue;
+                    }
+                    r2 = r2 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48754;
+                        continue;
+                    }
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                case 0x48680:
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4871c;
+                        continue;
+                    }
+                case 0x48688:
+                    r2 = r0 + r0;
+                case 0x4868c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x486a4:
+                    r3 = r2 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x487b0;
+                        continue;
+                    }
+                    r2 = r2 & 4;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48764;
+                        continue;
+                    }
+                    r3 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                case 0x486c0:
+                    r2 = r6 | 8;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r2 & 65535;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4865c;
+                        continue;
+                    }
+                case 0x486d4:
+                    r5 = r2 & 640;
+                    r4 = r0 + 512;
+                    if(r5 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4865c;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x486f4;
+                    pc=0x3e600;
+                    run_3e600(); return;
+                case 0x486f4:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x4865c;
+                    continue;
+                case 0x48704:
+                    r2 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    r2 = r0 - r2;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48688;
+                        continue;
+                    }
+                case 0x4871c:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + r0;
+                    r4 = r3 & 128;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4868c;
+                        continue;
+                    }
+                    r3 = r3 | 64;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4868c;
+                    continue;
+                case 0x48744:
+                    /* Next insn is delay slot */ 
+                    r31=0x4874c;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x4874c:
+                    /* Next insn is delay slot */ 
+                    pc=0x48634;
+                    continue;
+                case 0x48754:
+                    r2 = r0 + r0;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x48680;
+                    continue;
+                case 0x48764:
+                    r5 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48794;
+                        continue;
+                    }
+                    r2 = r16 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48790;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x4878c;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x4878c:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r6 = tmp;
+                case 0x48790:
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                case 0x48794:
+                    r3 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r2 = r0 + -37;
+                    r6 = r6 & r2;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x486c0;
+                    continue;
+                case 0x487b0:
+                    r2 = r0 + 9;
+                    r6 = r6 | 64;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r6&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x4868c;
+                    continue;
+                case 0x48800:
+                    pc=0x48800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_48800() throws ExecutionException { /* 0x48800 - 0x48a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x48800:
+                    r2 = r0 + 1;
+                    pc = 0x48804;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48808;
+                        return;
+                    }
+                case 0x48808:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48810:
+                    r2 = r0 + 2;
+                    pc = 0x48814;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48818;
+                        return;
+                    }
+                case 0x48818:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48820:
+                    r2 = r0 + 3;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48834;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48838;
+                        return;
+                    }
+                case 0x48838:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48850;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48850:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48860:
+                    r2 = r0 + 4;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48874;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48878;
+                        return;
+                    }
+                case 0x48878:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48890;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48890:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x488a0:
+                    r2 = r0 + 5;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x488b4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x488b8;
+                        return;
+                    }
+                case 0x488b8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x488d0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x488d0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x488e0:
+                    r2 = r0 + 6;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x488f4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x488f8;
+                        return;
+                    }
+                case 0x488f8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48910;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48910:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48920:
+                    r2 = r0 + 7;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48934;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48938;
+                        return;
+                    }
+                case 0x48938:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48950;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48950:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48960:
+                    r2 = r0 + 8;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48974;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48978;
+                        return;
+                    }
+                case 0x48978:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48990;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48990:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x489a0:
+                    r2 = r0 + 10;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x489b4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x489b8;
+                        return;
+                    }
+                case 0x489b8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x489d0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x489d0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x489e0:
+                    r2 = r0 + 11;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x489f4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x489f8;
+                        return;
+                    }
+                case 0x489f8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                case 0x48a00:
+                    pc=0x48a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_48a00() throws ExecutionException { /* 0x48a00 - 0x48c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x48a00:
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48a10;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48a10:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48a20:
+                    r2 = r0 + 12;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48a34;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48a38;
+                        return;
+                    }
+                case 0x48a38:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48a50;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48a50:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48a60:
+                    r2 = r0 + 13;
+                    pc = 0x48a64;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48a68;
+                        return;
+                    }
+                case 0x48a68:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48a70:
+                    r2 = r0 + 14;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48a84;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48a88;
+                        return;
+                    }
+                case 0x48a88:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48aa0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48aa0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48ab0:
+                    r2 = r0 + 15;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48ac4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48ac8;
+                        return;
+                    }
+                case 0x48ac8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48ae0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48ae0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48af0:
+                    r2 = r0 + 16;
+                    pc = 0x48af4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48af8;
+                        return;
+                    }
+                case 0x48af8:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48b00:
+                    r2 = r0 + 17;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48b14;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48b18;
+                        return;
+                    }
+                case 0x48b18:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48b30;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48b30:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48b40:
+                    r2 = r0 + 18;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48b54;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48b58;
+                        return;
+                    }
+                case 0x48b58:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48b70;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48b70:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48b80:
+                    r2 = r0 + 19;
+                    pc = 0x48b84;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48b88;
+                        return;
+                    }
+                case 0x48b88:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48b90:
+                    r2 = r0 + 20;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48ba4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48ba8;
+                        return;
+                    }
+                case 0x48ba8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48bc0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48bc0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48bd0:
+                    r2 = r0 + 21;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48be4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48be8;
+                        return;
+                    }
+                case 0x48be8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48c00;
+                        run_48c00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48c00:
+                    pc=0x48c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_48c00() throws ExecutionException { /* 0x48c00 - 0x48e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x48c00:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48c10:
+                    r2 = r0 + 22;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48c24;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48c28;
+                        return;
+                    }
+                case 0x48c28:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48c40;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48c40:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48c50:
+                    r2 = r0 + 23;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48c64;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48c68;
+                        return;
+                    }
+                case 0x48c68:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48c80;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48c80:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48c90:
+                    r2 = r0 + 24;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48ca4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48ca8;
+                        return;
+                    }
+                case 0x48ca8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48cc0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48cc0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48cd0:
+                    r2 = r0 + 25;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48ce4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48ce8;
+                        return;
+                    }
+                case 0x48ce8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48d00;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48d00:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48d10:
+                    r2 = r0 + 26;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48d24;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48d28;
+                        return;
+                    }
+                case 0x48d28:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48d40;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48d40:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48d50:
+                    r2 = r0 + 27;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48d64;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48d68;
+                        return;
+                    }
+                case 0x48d68:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48d80;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48d80:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48d90:
+                    r2 = r0 + 28;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48da4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48da8;
+                        return;
+                    }
+                case 0x48da8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48dc0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48dc0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48dd0:
+                    r2 = r0 + 29;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48de4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48de8;
+                        return;
+                    }
+                case 0x48de8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48e00;
+                        run_48e00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48e00:
+                    pc=0x48e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_48e00() throws ExecutionException { /* 0x48e00 - 0x49000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x48e00:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48e10:
+                    r2 = r0 + 30;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48e24;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48e28;
+                        return;
+                    }
+                case 0x48e28:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48e40;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48e40:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48e50:
+                    r2 = r0 + 31;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48e64;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48e68;
+                        return;
+                    }
+                case 0x48e68:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48e80;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48e80:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48e90:
+                    r2 = r0 + 32;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48ea4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48ea8;
+                        return;
+                    }
+                case 0x48ea8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48ec0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48ec0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48ed0:
+                    r2 = r0 + 33;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48ee4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48ee8;
+                        return;
+                    }
+                case 0x48ee8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48f00;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48f00:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48f10:
+                    r2 = r0 + 34;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48f24;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48f28;
+                        return;
+                    }
+                case 0x48f28:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48f40;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48f40:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48f50:
+                    r2 = r0 + 35;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x48f64;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48f68;
+                        return;
+                    }
+                case 0x48f68:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48f80;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48f80:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48f90:
+                    r2 = r0 + 36;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r8 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r9 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    pc = 0x48fb0;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48fb4;
+                        return;
+                    }
+                case 0x48fb4:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x48fcc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48fcc:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x48fdc:
+                    r2 = r0 + 37;
+                    pc = 0x48fe0;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48fe4;
+                        return;
+                    }
+                case 0x48fe4:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48fec:
+                    r2 = r0 + 38;
+                    pc = 0x48ff0;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x48ff4;
+                        return;
+                    }
+                case 0x48ff4:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x48ffc:
+                    r2 = r0 + 39;
+                case 0x49000:
+                    pc=0x49000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_49000() throws ExecutionException { /* 0x49000 - 0x49200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x49000:
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49010;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49014;
+                        return;
+                    }
+                case 0x49014:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4902c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4902c:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x4903c:
+                    r2 = r0 + 40;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49050;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49054;
+                        return;
+                    }
+                case 0x49054:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4906c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4906c:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x4907c:
+                    r2 = r0 + 41;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49090;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49094;
+                        return;
+                    }
+                case 0x49094:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x490ac;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x490ac:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x490bc:
+                    r2 = r0 + 42;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x490d0;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x490d4;
+                        return;
+                    }
+                case 0x490d4:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x490ec;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x490ec:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x490fc:
+                    r2 = r0 + 43;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49110;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49114;
+                        return;
+                    }
+                case 0x49114:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4912c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4912c:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x4913c:
+                    r2 = r0 + 44;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49150;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49154;
+                        return;
+                    }
+                case 0x49154:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4916c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4916c:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x4917c:
+                    r2 = r0 + 45;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49190;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49194;
+                        return;
+                    }
+                case 0x49194:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x491ac;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x491ac:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x491bc:
+                    r2 = r0 + 46;
+                    pc = 0x491c0;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x491c4;
+                        return;
+                    }
+                case 0x491c4:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x491cc:
+                    r2 = r0 + 47;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x491e0;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x491e4;
+                        return;
+                    }
+                case 0x491e4:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x491fc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x491fc:
+                    r4 = r10 + r0;
+                case 0x49200:
+                    pc=0x49200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_49200() throws ExecutionException { /* 0x49200 - 0x49400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x49200:
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x4920c:
+                    r2 = r0 + 51;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49220;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49224;
+                        return;
+                    }
+                case 0x49224:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4923c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4923c:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x4924c:
+                    r2 = r0 + 52;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49260;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49264;
+                        return;
+                    }
+                case 0x49264:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4927c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4927c:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x4928c:
+                    r2 = r0 + 53;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r8 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r9 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    pc = 0x492ac;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x492b0;
+                        return;
+                    }
+                case 0x492b0:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x492c8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x492c8:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x492d8:
+                    r2 = r0 + 55;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x492ec;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x492f0;
+                        return;
+                    }
+                case 0x492f0:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49308;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49308:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49318:
+                    r2 = r0 + 54;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x4932c;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49330;
+                        return;
+                    }
+                case 0x49330:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49348;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49348:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49358:
+                    r2 = r0 + 56;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x4936c;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49370;
+                        return;
+                    }
+                case 0x49370:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49388;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49388:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49398:
+                    r2 = r0 + 57;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x493ac;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x493b0;
+                        return;
+                    }
+                case 0x493b0:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x493c8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x493c8:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x493d8:
+                    r2 = r0 + 58;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x493ec;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x493f0;
+                        return;
+                    }
+                case 0x493f0:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49408;
+                        run_49400(); return;
+                    }
+                case 0x49400:
+                    pc=0x49400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_49400() throws ExecutionException { /* 0x49400 - 0x49600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x49400:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49408:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49418:
+                    r2 = r0 + 59;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x4942c;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49430;
+                        return;
+                    }
+                case 0x49430:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49448;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49448:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49458:
+                    r2 = r0 + 60;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r8 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r9 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    pc = 0x49478;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4947c;
+                        return;
+                    }
+                case 0x4947c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49494;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49494:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x494a4:
+                    r2 = r0 + 61;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r8 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r9 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    pc = 0x494c4;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x494c8;
+                        return;
+                    }
+                case 0x494c8:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x494e0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x494e0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x494f0:
+                    r2 = r0 + 62;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49504;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49508;
+                        return;
+                    }
+                case 0x49508:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49520;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49520:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49530:
+                    r2 = r0 + 63;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49544;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49548;
+                        return;
+                    }
+                case 0x49548:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49560;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49560:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49570:
+                    r2 = r0 + 64;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49584;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49588;
+                        return;
+                    }
+                case 0x49588:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x495a0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x495a0:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x495b0:
+                    r2 = r0 + 65;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r8 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r9 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    pc = 0x495d0;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x495d4;
+                        return;
+                    }
+                case 0x495d4:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x495ec;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x495ec:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x495fc:
+                    r2 = r0 + 66;
+                case 0x49600:
+                    pc=0x49600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_49600() throws ExecutionException { /* 0x49600 - 0x49800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x49600:
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r8 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r9 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    pc = 0x4961c;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49620;
+                        return;
+                    }
+                case 0x49620:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49638;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49638:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49648:
+                    r2 = r0 + 67;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r8 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r9 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    pc = 0x49668;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4966c;
+                        return;
+                    }
+                case 0x4966c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49684;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49684:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49694:
+                    r2 = r0 + 73;
+                    pc = 0x49698;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4969c;
+                        return;
+                    }
+                case 0x4969c:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x496a4:
+                    r2 = r0 + 68;
+                    pc = 0x496a8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x496ac;
+                        return;
+                    }
+                case 0x496ac:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x496b4:
+                    r2 = r0 + 70;
+                    pc = 0x496b8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x496bc;
+                        return;
+                    }
+                case 0x496bc:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x496c4:
+                    r2 = r0 + 69;
+                    pc = 0x496c8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x496cc;
+                        return;
+                    }
+                case 0x496cc:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x496d4:
+                    r2 = r0 + 71;
+                    pc = 0x496d8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x496dc;
+                        return;
+                    }
+                case 0x496dc:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x496e4:
+                    r2 = r0 + 82;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x496f8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x496fc;
+                        return;
+                    }
+                case 0x496fc:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49714;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49714:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49724:
+                    r2 = r0 + 83;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49738;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4973c;
+                        return;
+                    }
+                case 0x4973c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49754;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49754:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49764:
+                    r2 = r0 + 84;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49778;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4977c;
+                        return;
+                    }
+                case 0x4977c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49794;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49794:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x497a4:
+                    r2 = r0 + 85;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x497b8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x497bc;
+                        return;
+                    }
+                case 0x497bc:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x497d4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x497d4:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x497e4:
+                    r2 = r0 + 80;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x497f8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x497fc;
+                        return;
+                    }
+                case 0x497fc:
+                    r11 = r2 + 255;
+                case 0x49800:
+                    pc=0x49800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_49800() throws ExecutionException { /* 0x49800 - 0x49a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x49800:
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49814;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49814:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49824:
+                    r2 = r0 + 86;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49838;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4983c;
+                        return;
+                    }
+                case 0x4983c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49854;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49854:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49864:
+                    r2 = r0 + 81;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49878;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4987c;
+                        return;
+                    }
+                case 0x4987c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49894;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49894:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x498a4:
+                    r2 = r0 + 87;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x498b8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x498bc;
+                        return;
+                    }
+                case 0x498bc:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x498d4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x498d4:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x498e4:
+                    r2 = r0 + 88;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x498f8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x498fc;
+                        return;
+                    }
+                case 0x498fc:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49914;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49914:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49924:
+                    r2 = r0 + 78;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49938;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4993c;
+                        return;
+                    }
+                case 0x4993c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49954;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49954:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49964:
+                    r2 = r0 + 76;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49978;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x4997c;
+                        return;
+                    }
+                case 0x4997c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49994;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49994:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x499a4:
+                    r2 = r0 + 77;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x499b8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x499bc;
+                        return;
+                    }
+                case 0x499bc:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x499d4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x499d4:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x499e4:
+                    r2 = r0 + 74;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x499f8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x499fc;
+                        return;
+                    }
+                case 0x499fc:
+                    r11 = r2 + 255;
+                case 0x49a00:
+                    pc=0x49a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_49a00() throws ExecutionException { /* 0x49a00 - 0x49c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x49a00:
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49a14;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49a14:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49a24:
+                    r2 = r0 + 75;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49a38;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49a3c;
+                        return;
+                    }
+                case 0x49a3c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49a54;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49a54:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49a64:
+                    r2 = r0 + 79;
+                    pc = 0x49a68;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49a6c;
+                        return;
+                    }
+                case 0x49a6c:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49a74:
+                    r2 = r0 + 72;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49a88;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49a8c;
+                        return;
+                    }
+                case 0x49a8c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49aa4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49aa4:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49ab4:
+                    r2 = r0 + 90;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49ac8;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49acc;
+                        return;
+                    }
+                case 0x49acc:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49ae4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49ae4:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49af4:
+                    r2 = r0 + 89;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49b08;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49b0c;
+                        return;
+                    }
+                case 0x49b0c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49b24;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49b24:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49b34:
+                    r2 = r0 + 91;
+                    r10 = r4 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    r6 = r7 + r0;
+                    pc = 0x49b48;
+                    r2 = syscall(r2,r4,r5,r6,r7,r8,r9);
+                    if (state != RUNNING) {
+                        pc = 0x49b4c;
+                        return;
+                    }
+                case 0x49b4c:
+                    r11 = r2 + 255;
+                    r11 = (r11&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x49b64;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49b64:
+                    r4 = r10 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49c00;
+                    run_49c00(); return;
+                case 0x49c00:
+                    pc=0x49c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_49c00() throws ExecutionException { /* 0x49c00 - 0x49e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x49c00:
+                    r5 = r0 - r5;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x49e00:
+                    pc=0x49e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_49e00() throws ExecutionException { /* 0x49e00 - 0x4a000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x49e00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48b40;
+                    run_48a00(); return;
+                case 0x4a000:
+                    pc=0x4a000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4a000() throws ExecutionException { /* 0x4a000 - 0x4a200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4a000:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49924;
+                    run_49800(); return;
+                case 0x4a200:
+                    pc=0x4a200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4a200() throws ExecutionException { /* 0x4a200 - 0x4a400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4a200:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x48e10;
+                    run_48e00(); return;
+                case 0x4a400:
+                    pc=0x4a400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4a400() throws ExecutionException { /* 0x4a400 - 0x4a600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4a400:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x48e50;
+                    run_48e00(); return;
+                case 0x4a600:
+                    pc=0x4a600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4a600() throws ExecutionException { /* 0x4a600 - 0x4a800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4a600:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x48c10;
+                    run_48c00(); return;
+                case 0x4a800:
+                    pc=0x4a800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4a800() throws ExecutionException { /* 0x4a800 - 0x4aa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4a800:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48bd0;
+                    run_48a00(); return;
+                case 0x4aa00:
+                    pc=0x4aa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4aa00() throws ExecutionException { /* 0x4aa00 - 0x4ac00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4aa00:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x48c50;
+                    run_48c00(); return;
+                case 0x4ac00:
+                    pc=0x4ac00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4ac00() throws ExecutionException { /* 0x4ac00 - 0x4ae00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4ac00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48c90;
+                    run_48c00(); return;
+                case 0x4ae00:
+                    pc=0x4ae00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4ae00() throws ExecutionException { /* 0x4ae00 - 0x4b000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4ae00:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48d10;
+                    run_48c00(); return;
+                case 0x4b000:
+                    pc=0x4b000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4b000() throws ExecutionException { /* 0x4b000 - 0x4b200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4b000:
+                    r29 = r29 + -40;
+                    r2 = r4 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r18 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4b070;
+                        continue;
+                    }
+                    r6 = r5 + r0;
+                    r4 = r18 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x4b040;
+                    pc=0x48d50;
+                    run_48c00(); return;
+                case 0x4b040:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4b0c4;
+                        continue;
+                    }
+                case 0x4b04c:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4b070:
+                    r16 = r0 + 256;
+                    r19 = r0 + -1;
+                    r20 = r0 + 34;
+                case 0x4b07c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x4b088;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x4b088:
+                    r5 = r2 + r0;
+                    r4 = r18 + r0;
+                    r6 = r16 + r0;
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x4b0a0;
+                    pc=0x48d50;
+                    run_48c00(); return;
+                case 0x4b0a0:
+                    if(r2 != r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4b04c;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x4b0b4;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x4b0b4:
+                    r2 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    r16 = r16 << 1;
+                    if(r2 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4b07c;
+                        continue;
+                    }
+                case 0x4b0c4:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4b200:
+                    pc=0x4b200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4b200() throws ExecutionException { /* 0x4b200 - 0x4b400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4b200:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48d50;
+                    run_48c00(); return;
+                case 0x4b400:
+                    pc=0x4b400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4b400() throws ExecutionException { /* 0x4b400 - 0x4b600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4b400:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48f10;
+                    run_48e00(); return;
+                case 0x4b600:
+                    pc=0x4b600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4b600() throws ExecutionException { /* 0x4b600 - 0x4b800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4b600:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48e90;
+                    run_48e00(); return;
+                case 0x4b800:
+                    pc=0x4b800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4b800() throws ExecutionException { /* 0x4b800 - 0x4ba00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4b800:
+                    r3 = r4 + r0;
+                    r2 = r5 & 65535;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 & 65535;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49964;
+                    run_49800(); return;
+                case 0x4ba00:
+                    pc=0x4ba00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4ba00() throws ExecutionException { /* 0x4ba00 - 0x4bc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4ba00:
+                    r3 = r4 + r0;
+                    r2 = r5 & 65535;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 & 65535;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x499a4;
+                    run_49800(); return;
+                case 0x4bc00:
+                    pc=0x4bc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4bc00() throws ExecutionException { /* 0x4bc00 - 0x4be00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4bc00:
+                    r3 = r4 + r0;
+                    r2 = r5 & 65535;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 & 65535;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x490fc;
+                    run_49000(); return;
+                case 0x4be00:
+                    pc=0x4be00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4be00() throws ExecutionException { /* 0x4be00 - 0x4c000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4be00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x499e4;
+                    run_49800(); return;
+                case 0x4c000:
+                    pc=0x4c000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4c000() throws ExecutionException { /* 0x4c000 - 0x4c200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4c000:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49a24;
+                    run_49a00(); return;
+                case 0x4c200:
+                    pc=0x4c200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4c200() throws ExecutionException { /* 0x4c200 - 0x4c400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4c200:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48ed0;
+                    run_48e00(); return;
+                case 0x4c400:
+                    pc=0x4c400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4c400() throws ExecutionException { /* 0x4c400 - 0x4c600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4c400:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r8 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4c430;
+                    pc=0x48f90;
+                    run_48e00(); return;
+                case 0x4c430:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4c600:
+                    pc=0x4c600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4c600() throws ExecutionException { /* 0x4c600 - 0x4c800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4c600:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x48ffc;
+                    run_48e00(); return;
+                case 0x4c800:
+                    pc=0x4c800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4c800() throws ExecutionException { /* 0x4c800 - 0x4ca00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4c800:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r4 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r5 = r5 + 1056;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4c828;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x4c828:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 22;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4ca00:
+                    pc=0x4ca00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4ca00() throws ExecutionException { /* 0x4ca00 - 0x4cc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4ca00:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x4903c;
+                    run_49000(); return;
+                case 0x4cc00:
+                    pc=0x4cc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4cc00() throws ExecutionException { /* 0x4cc00 - 0x4ce00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4cc00:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x4907c;
+                    run_49000(); return;
+                case 0x4ce00:
+                    pc=0x4ce00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4ce00() throws ExecutionException { /* 0x4ce00 - 0x4d000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4ce00:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r7 = r6 << 16;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r7 >> 16;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x490bc;
+                    run_49000(); return;
+                case 0x4d000:
+                    pc=0x4d000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4d000() throws ExecutionException { /* 0x4d000 - 0x4d200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4d000:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4913c;
+                    run_49000(); return;
+                case 0x4d200:
+                    pc=0x4d200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4d200() throws ExecutionException { /* 0x4d200 - 0x4d400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4d200:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x4917c;
+                    run_49000(); return;
+                case 0x4d400:
+                    pc=0x4d400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4d400() throws ExecutionException { /* 0x4d400 - 0x4d600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4d400:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x491cc;
+                    run_49000(); return;
+                case 0x4d600:
+                    pc=0x4d600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4d600() throws ExecutionException { /* 0x4d600 - 0x4d800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4d600:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4920c;
+                    run_49200(); return;
+                case 0x4d800:
+                    pc=0x4d800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4d800() throws ExecutionException { /* 0x4d800 - 0x4da00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4d800:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x4924c;
+                    run_49200(); return;
+                case 0x4da00:
+                    pc=0x4da00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4da00() throws ExecutionException { /* 0x4da00 - 0x4dc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4da00:
+                    r29 = r29 + -40;
+                    r8 = r4 + r0;
+                    r4 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r3 = r5 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r2 = r6 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r5 = r8 + r0;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4da40;
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x4da40:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4dc00:
+                    pc=0x4dc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4dc00() throws ExecutionException { /* 0x4dc00 - 0x4de00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4dc00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r29 = r29 + -40;
+                    r3 = r0 + 8;
+                    r8 = r5 + r0;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    r16 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4dc64;
+                        continue;
+                    }
+                    r3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4dca8;
+                        continue;
+                    }
+                    r3 = r0 + 2;
+                    if(r5 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x4dcc8;
+                        continue;
+                    }
+                case 0x4dc44:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r0 + 22;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4dc64:
+                    r3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r9 = r6 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r3;
+                    r4 = r16 + r0;
+                    r5 = r2 + r0;
+                    r6 = r8 + r0;
+                    r7 = r9 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x4dc94;
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x4dc94:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4dca8:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4dcc8:
+                    r4 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r6 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = r5 + 1096;
+                    /* Next insn is delay slot */ 
+                    r31=0x4dce0;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x4dce0:
+                    /* Next insn is delay slot */ 
+                    pc=0x4dc44;
+                    continue;
+                case 0x4de00:
+                    pc=0x4de00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4de00() throws ExecutionException { /* 0x4de00 - 0x4e000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4de00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x492d8;
+                    run_49200(); return;
+                case 0x4e000:
+                    pc=0x4e000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4e000() throws ExecutionException { /* 0x4e000 - 0x4e200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4e000:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49318;
+                    run_49200(); return;
+                case 0x4e200:
+                    pc=0x4e200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4e200() throws ExecutionException { /* 0x4e200 - 0x4e400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4e200:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49398;
+                    run_49200(); return;
+                case 0x4e400:
+                    pc=0x4e400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4e400() throws ExecutionException { /* 0x4e400 - 0x4e600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4e400:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49358;
+                    run_49200(); return;
+                case 0x4e600:
+                    pc=0x4e600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4e600() throws ExecutionException { /* 0x4e600 - 0x4e800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4e600:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x493d8;
+                    run_49200(); return;
+                case 0x4e800:
+                    pc=0x4e800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4e800() throws ExecutionException { /* 0x4e800 - 0x4ea00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4e800:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49af4;
+                    run_49a00(); return;
+                case 0x4ea00:
+                    pc=0x4ea00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4ea00() throws ExecutionException { /* 0x4ea00 - 0x4ec00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4ea00:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49418;
+                    run_49400(); return;
+                case 0x4ec00:
+                    pc=0x4ec00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4ec00() throws ExecutionException { /* 0x4ec00 - 0x4ee00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4ec00:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r4 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r5 = r8 + r0;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4ec38;
+                    pc=0x494a4;
+                    run_49400(); return;
+                case 0x4ec38:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4ee00:
+                    pc=0x4ee00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4ee00() throws ExecutionException { /* 0x4ee00 - 0x4f000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4ee00:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r4 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r5 = r8 + r0;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4ee38;
+                    pc=0x49458;
+                    run_49400(); return;
+                case 0x4ee38:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4f000:
+                    pc=0x4f000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4f000() throws ExecutionException { /* 0x4f000 - 0x4f200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4f000:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49530;
+                    run_49400(); return;
+                case 0x4f200:
+                    pc=0x4f200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4f200() throws ExecutionException { /* 0x4f200 - 0x4f400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4f200:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x494f0;
+                    run_49400(); return;
+                case 0x4f400:
+                    pc=0x4f400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4f400() throws ExecutionException { /* 0x4f400 - 0x4f600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4f400:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49570;
+                    run_49400(); return;
+                case 0x4f600:
+                    pc=0x4f600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4f600() throws ExecutionException { /* 0x4f600 - 0x4f800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4f600:
+                    r29 = r29 + -40;
+                    r8 = r4 + r0;
+                    r4 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r3 = r5 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r2 = r6 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r5 = r8 + r0;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4f640;
+                    pc=0x495b0;
+                    run_49400(); return;
+                case 0x4f640:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4f800:
+                    pc=0x4f800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4f800() throws ExecutionException { /* 0x4f800 - 0x4fa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4f800:
+                    r29 = r29 + -40;
+                    r8 = r4 + r0;
+                    r4 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r3 = r5 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r2 = r6 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r5 = r8 + r0;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4f840;
+                    pc=0x495fc;
+                    run_49400(); return;
+                case 0x4f840:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4fa00:
+                    pc=0x4fa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4fa00() throws ExecutionException { /* 0x4fa00 - 0x4fc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4fa00:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r4 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r5 = r8 + r0;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4fa38;
+                    pc=0x49648;
+                    run_49600(); return;
+                case 0x4fa38:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4fc00:
+                    pc=0x4fc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4fc00() throws ExecutionException { /* 0x4fc00 - 0x4fe00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4fc00:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r8 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4fc30;
+                    pc=0x496e4;
+                    run_49600(); return;
+                case 0x4fc30:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x4fe00:
+                    pc=0x4fe00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_4fe00() throws ExecutionException { /* 0x4fe00 - 0x50000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x4fe00:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r8 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x4fe30;
+                    pc=0x49724;
+                    run_49600(); return;
+                case 0x4fe30:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x50000:
+                    pc=0x50000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_50000() throws ExecutionException { /* 0x50000 - 0x50200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x50000:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49a74;
+                    run_49a00(); return;
+                case 0x50200:
+                    pc=0x50200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_50200() throws ExecutionException { /* 0x50200 - 0x50400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x50200:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x49764;
+                    run_49600(); return;
+                case 0x50400:
+                    pc=0x50400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_50400() throws ExecutionException { /* 0x50400 - 0x50600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x50400:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x497a4;
+                    run_49600(); return;
+                case 0x50600:
+                    pc=0x50600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_50600() throws ExecutionException { /* 0x50600 - 0x50800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x50600:
+                    r5 = r4 & 65535;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x497e4;
+                    run_49600(); return;
+                case 0x50800:
+                    pc=0x50800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_50800() throws ExecutionException { /* 0x50800 - 0x50a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x50800:
+                    r5 = r4 & 65535;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x49824;
+                    run_49800(); return;
+                case 0x50a00:
+                    pc=0x50a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_50a00() throws ExecutionException { /* 0x50a00 - 0x50c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x50a00:
+                    r5 = r4 & 65535;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x49864;
+                    run_49800(); return;
+                case 0x50c00:
+                    pc=0x50c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_50c00() throws ExecutionException { /* 0x50c00 - 0x50e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x50c00:
+                    r5 = r4 & 65535;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x498a4;
+                    run_49800(); return;
+                case 0x50e00:
+                    pc=0x50e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_50e00() throws ExecutionException { /* 0x50e00 - 0x51000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x50e00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x498e4;
+                    run_49800(); return;
+                case 0x51000:
+                    pc=0x51000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_51000() throws ExecutionException { /* 0x51000 - 0x51200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x51000:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x49ab4;
+                    run_49a00(); return;
+                case 0x51200:
+                    pc=0x51200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_51200() throws ExecutionException { /* 0x51200 - 0x51400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x51200:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x49b34;
+                    run_49a00(); return;
+                case 0x51400:
+                    pc=0x51400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_51400() throws ExecutionException { /* 0x51400 - 0x51600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x51400:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48d90;
+                    run_48c00(); return;
+                case 0x51600:
+                    pc=0x51600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_51600() throws ExecutionException { /* 0x51600 - 0x51800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x51600:
+                    r29 = r29 + -40;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5165c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x5162c;
+                    pc=0x48d50;
+                    run_48c00(); return;
+                case 0x5162c:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x516b4;
+                        continue;
+                    }
+                case 0x51638:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5165c:
+                    r18 = r4 + r0;
+                    r16 = r0 + 256;
+                    r19 = r0 + -1;
+                    r20 = r0 + 34;
+                case 0x5166c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x51678;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x51678:
+                    r5 = r2 + r0;
+                    r4 = r18 + r0;
+                    r6 = r16 + r0;
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x51690;
+                    pc=0x48d50;
+                    run_48c00(); return;
+                case 0x51690:
+                    if(r2 != r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x51638;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x516a4;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x516a4:
+                    r2 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    r16 = r16 << 1;
+                    if(r2 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5166c;
+                        continue;
+                    }
+                case 0x516b4:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x51800:
+                    pc=0x51800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_51800() throws ExecutionException { /* 0x51800 - 0x51a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x51800:
+                    r6 = r5 + r0;
+                    r7 = r0 + r0;
+                    r5 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x48d10;
+                    run_48c00(); return;
+                case 0x51a00:
+                    pc=0x51a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_51a00() throws ExecutionException { /* 0x51a00 - 0x51c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x51a00:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    r5 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r5 = r5 + 1056;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x51a28;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x51a28:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 22;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x51c00:
+                    pc=0x51c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_51c00() throws ExecutionException { /* 0x51c00 - 0x51e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x51c00:
+                    r8 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    r3 = r0 + 8;
+                    r2 = r5 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r9 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    if(r8 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x51c5c;
+                        continue;
+                    }
+                    r16 = r4 + r0;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x51c74;
+                        continue;
+                    }
+                    r3 = r0 + 2;
+                    if(r6 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x51c94;
+                        continue;
+                    }
+                case 0x51c3c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 22;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x51c5c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x51c74:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x51c94:
+                    r3 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r4 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r6 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = r5 + 1096;
+                    /* Next insn is delay slot */ 
+                    r31=0x51cb0;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x51cb0:
+                    /* Next insn is delay slot */ 
+                    pc=0x51c3c;
+                    continue;
+                case 0x51e00:
+                    pc=0x51e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_51e00() throws ExecutionException { /* 0x51e00 - 0x52000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x51e00:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x52000:
+                    pc=0x52000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_52000() throws ExecutionException { /* 0x52000 - 0x52200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x52000:
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x52010;
+                    pc=0x5a200;
+                    run_5a200(); return;
+                case 0x52010:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52030;
+                        continue;
+                    }
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r2 = r2 + 1132;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x52030:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x52200:
+                    pc=0x52200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_52200() throws ExecutionException { /* 0x52200 - 0x52400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x52200:
+                    r29 = r29 + -32;
+                    r2 = r5 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r16 = r6 + r0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x522b8;
+                        continue;
+                    }
+                    r3 = readPages[(r5+8)>>>12][((r5+8)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52288;
+                        continue;
+                    }
+                    r5 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    r3 = r0 + -1;
+                    if(r5 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52288;
+                        continue;
+                    }
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x52250;
+                    pc=0x5ea00;
+                    run_5ea00(); return;
+                case 0x52250:
+                    r17 = r2 + r0;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52268;
+                        continue;
+                    }
+                case 0x5225c:
+                    r2 = r0 + -1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r17;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                case 0x52268:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x52288:
+                    /* Next insn is delay slot */ 
+                    r31=0x52290;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x52290:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r3 = r0 + 22;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x522b8:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52268;
+                        continue;
+                    }
+                    r18 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x522cc;
+                    pc=0x5ea00;
+                    run_5ea00(); return;
+                case 0x522cc:
+                    r5 = r2 + r0;
+                    r4 = r18 + r0;
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x522e0;
+                    pc=0x5ea00;
+                    run_5ea00(); return;
+                case 0x522e0:
+                    /* Next insn is delay slot */ 
+                    pc=0x5225c;
+                    continue;
+                case 0x52400:
+                    pc=0x52400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_52400() throws ExecutionException { /* 0x52400 - 0x52600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x52400:
+                    r29 = r29 + -96;
+                    r5 = r0 + r0;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r17;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r31;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x5241c;
+                    pc=0x63000;
+                    run_63000(); return;
+                case 0x5241c:
+                    r17 = r2 + r0;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x524ec;
+                        continue;
+                    }
+                    r4 = r2 + r0;
+                    r5 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x52438;
+                    pc=0x62e00;
+                    run_62e00(); return;
+                case 0x52438:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x524b4;
+                        continue;
+                    }
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 16384;
+                    r3 = r3 & 61440;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x524b4;
+                        continue;
+                    }
+                    r4 = r0 + 20;
+                    /* Next insn is delay slot */ 
+                    r31=0x52460;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x52460:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x524f8;
+                        continue;
+                    }
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r17;
+                    r4 = r0 + 4096;
+                    /* Next insn is delay slot */ 
+                    r31=0x5247c;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x5247c:
+                    r3 = r0 + 4096;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r3;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52520;
+                        continue;
+                    }
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r0;
+                    r2 = r16 + r0;
+                case 0x5249c:
+                    r31 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r17 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r16 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r29 = r29 + 96;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x524b4:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x524c0;
+                    pc=0x62a00;
+                    run_62a00(); return;
+                case 0x524c0:
+                    /* Next insn is delay slot */ 
+                    r31=0x524c8;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x524c8:
+                    r31 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r3 = r0 + 20;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r17 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r16 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 96;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x524ec:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5249c;
+                    continue;
+                case 0x524f8:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x52504;
+                    pc=0x62a00;
+                    run_62a00(); return;
+                case 0x52504:
+                    /* Next insn is delay slot */ 
+                    r31=0x5250c;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x5250c:
+                    r3 = r0 + 12;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5249c;
+                    continue;
+                case 0x52520:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5252c;
+                    pc=0x62a00;
+                    run_62a00(); return;
+                case 0x5252c:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x52538;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x52538:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5249c;
+                    continue;
+                case 0x52600:
+                    pc=0x52600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_52600() throws ExecutionException { /* 0x52600 - 0x52800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x52600:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x52618;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x52618:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52684;
+                        continue;
+                    }
+                    r5 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52684;
+                        continue;
+                    }
+                    r6 = r3 + r0;
+                case 0x5263c:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r2 + r6;
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x526c4;
+                        continue;
+                    }
+                    r3 = r5 - r3;
+                    r3 = ((r3 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x526c4;
+                        continue;
+                    }
+                    r4 = r6 + r4;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r4;
+                case 0x52670:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x52684:
+                    r5 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r6 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r7 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x526a0;
+                    pc=0x48f90;
+                    run_48e00(); return;
+                case 0x526a0:
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r2;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x526dc;
+                        continue;
+                    }
+                    r5 = r2 + r0;
+                    r6 = r0 + r0;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5263c;
+                    continue;
+                case 0x526c4:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x526dc:
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r0;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x52670;
+                    continue;
+                case 0x52800:
+                    pc=0x52800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_52800() throws ExecutionException { /* 0x52800 - 0x52a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x52800:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r16 = r4 + r0;
+                    r4 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x52824;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x52824:
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x52830;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x52830:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x62a00;
+                    run_62a00(); return;
+                case 0x52a00:
+                    pc=0x52a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_52a00() throws ExecutionException { /* 0x52a00 - 0x52c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x52a00:
+                    r2 = r4 >>> 16;
+                    r29 = r29 + -40;
+                    r2 = r2 & 255;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = r4 >>> 8;
+                    r2 = r2 & 255;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    r16 = 7 << 16;
+                    r2 = r4 & 255;
+                    r7 = r4 + r0;
+                    r6 = 7 << 16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    r4 = r16 + 23428;
+                    r5 = r0 + 18;
+                    r6 = r6 + 1148;
+                    r7 = r7 >>> 24;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x52a50;
+                    pc=0x41c00;
+                    run_41c00(); return;
+                case 0x52a50:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r16 + 23428;
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x52c00:
+                    pc=0x52c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_52c00() throws ExecutionException { /* 0x52c00 - 0x52e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x52c00:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x52e00:
+                    pc=0x52e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_52e00() throws ExecutionException { /* 0x52e00 - 0x53000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x52e00:
+                    r2 = (r4&0xffffffffL) < (5&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x52e28;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + 1396;
+                    r4 = r4 << 2;
+                    r4 = r4 + r2;
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x52e28:
+                    r2 = 7 << 16;
+                    r2 = r2 + 1160;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x53000:
+                    pc=0x53000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_53000() throws ExecutionException { /* 0x53000 - 0x53200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x53000:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r4 + r0;
+                    r4 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30568)>>>12][((r28+-30568)>>>2)&0x3ff];
+                    r3 = (r2&0xffffffffL) < (5&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53044;
+                        continue;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + 1396;
+                    r2 = r2 + r3;
+                    r5 = 7 << 16;
+                    r7 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r5 = r5 + 1176;
+                    /* Next insn is delay slot */ 
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x53044:
+                    r7 = 7 << 16;
+                    r5 = 7 << 16;
+                    r7 = r7 + 1160;
+                    r5 = r5 + 1176;
+                    /* Next insn is delay slot */ 
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x53200:
+                    pc=0x53200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_53200() throws ExecutionException { /* 0x53200 - 0x53400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x53200:
+                    r29 = r29 + -40;
+                    r2 = r0 + 2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    r16 = r6 + r0;
+                    if(r6 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x532d4;
+                        continue;
+                    }
+                    r2 = r0 + 4;
+                    r17 = r5 + r0;
+                    if(r5 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x532d4;
+                        continue;
+                    }
+                    r18 = r4 + r0;
+                    r5 = r18 + r0;
+                    r4 = r29 + 16;
+                    r6 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    r31=0x5324c;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x5324c:
+                    r5 = r18 + r0;
+                    r4 = r28 + -30624;
+                    r6 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    r31=0x53260;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x53260:
+                    r18 = 7 << 16;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r6 = r18 + 23300;
+                    r7 = r0 + 128;
+                    /* Next insn is delay slot */ 
+                    r31=0x5327c;
+                    pc=0x49af4;
+                    run_49a00(); return;
+                case 0x5327c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x532f4;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r18 = r18 + 23300;
+                    writePages[(r2+23280)>>>12][((r2+23280)>>>2)&0x3ff] = r18;
+                    r3 = r28 + -30628;
+                    r2 = r2 + 23280;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r3 = r28 + -30632;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    r3 = r28 + -30624;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r16;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r17;
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    writePages[(r28+-30628)>>>12][((r28+-30628)>>>2)&0x3ff] = r0;
+                    writePages[(r28+-30632)>>>12][((r28+-30632)>>>2)&0x3ff] = r3;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x532d4:
+                    r2 = r0 + r0;
+                case 0x532d8:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x532f4:
+                    writePages[(r28+-30568)>>>12][((r28+-30568)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x532d8;
+                    continue;
+                case 0x53400:
+                    pc=0x53400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_53400() throws ExecutionException { /* 0x53400 - 0x53600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x53400:
+                    r29 = r29 + -1064;
+                    writePages[(r29+1056)>>>12][((r29+1056)>>>2)&0x3ff] = r18;
+                    r18 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r2 = r0 + 1024;
+                    r5 = r18 + r0;
+                    r6 = r29 + 16;
+                    r7 = r29 + 1040;
+                    writePages[(r29+1060)>>>12][((r29+1060)>>>2)&0x3ff] = r31;
+                    writePages[(r29+1052)>>>12][((r29+1052)>>>2)&0x3ff] = r17;
+                    writePages[(r29+1048)>>>12][((r29+1048)>>>2)&0x3ff] = r16;
+                    writePages[(r29+1040)>>>12][((r29+1040)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x53438;
+                    pc=0x493d8;
+                    run_49200(); return;
+                case 0x53438:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5351c;
+                        continue;
+                    }
+                    r17 = readPages[(r29+1040)>>>12][((r29+1040)>>>2)&0x3ff];
+                    r9 = 7 << 16;
+                    r9 = r9 + 22256;
+                    r4 = r9 + r0;
+                    r5 = r29 + 16;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x53460;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x53460:
+                    r9 = r2 + r0;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53540;
+                        continue;
+                    }
+                    r16 = 7 << 16;
+                    r3 = r0 + r0;
+                    r7 = r0 + r0;
+                    r2 = r0 + r0;
+                    r16 = r16 + 21228;
+                    /* Next insn is delay slot */ 
+                    pc=0x5348c;
+                    continue;
+                case 0x53488:
+                    r3 = r2 + r0;
+                case 0x5348c:
+                    r8 = r16 + r3;
+                    r2 = r9 + r2;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r2;
+                    r2 = r3 + 4;
+                    r3 = ((r2 & 0xffffffffL) < (r17 & 0xffffffffL)) ? 1 : 0;
+                    r7 = r7 + 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53488;
+                        continue;
+                    }
+                case 0x534ac:
+                    r2 = r7 << 2;
+                    r17 = 7 << 16;
+                    r2 = r16 + r2;
+                    r4 = r17 + 21100;
+                    r5 = r18 + r0;
+                    r6 = r0 + 128;
+                    r17 = r17 + 21100;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x534d4;
+                    pc=0x5f400;
+                    run_5f400(); return;
+                case 0x534d4:
+                    r2 = 7 << 16;
+                    writePages[(r2+21080)>>>12][((r2+21080)>>>2)&0x3ff] = r17;
+                    r3 = r28 + -30636;
+                    r2 = r2 + 21080;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r3;
+                    r31 = readPages[(r29+1060)>>>12][((r29+1060)>>>2)&0x3ff];
+                    r3 = r0 + 2;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 4;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r16;
+                    r18 = readPages[(r29+1056)>>>12][((r29+1056)>>>2)&0x3ff];
+                    r17 = readPages[(r29+1052)>>>12][((r29+1052)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1048)>>>12][((r29+1048)>>>2)&0x3ff];
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    writePages[(r28+-30636)>>>12][((r28+-30636)>>>2)&0x3ff] = r0;
+                    r29 = r29 + 1064;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5351c:
+                    r31 = readPages[(r29+1060)>>>12][((r29+1060)>>>2)&0x3ff];
+                    r18 = readPages[(r29+1056)>>>12][((r29+1056)>>>2)&0x3ff];
+                    r17 = readPages[(r29+1052)>>>12][((r29+1052)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1048)>>>12][((r29+1048)>>>2)&0x3ff];
+                    writePages[(r28+-30568)>>>12][((r28+-30568)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    r29 = r29 + 1064;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x53540:
+                    r16 = 7 << 16;
+                    r7 = r0 + r0;
+                    r16 = r16 + 21228;
+                    /* Next insn is delay slot */ 
+                    pc=0x534ac;
+                    continue;
+                case 0x53600:
+                    pc=0x53600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_53600() throws ExecutionException { /* 0x53600 - 0x53800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x53600:
+                    r29 = r29 + -1088;
+                    r5 = 7 << 16;
+                    writePages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff] = r30;
+                    r30 = r4 + r0;
+                    r4 = 7 << 16;
+                    r4 = r4 + 1184;
+                    r5 = r5 + -632;
+                    writePages[(r29+1052)>>>12][((r29+1052)>>>2)&0x3ff] = r17;
+                    writePages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff] = r31;
+                    writePages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff] = r23;
+                    writePages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff] = r22;
+                    writePages[(r29+1068)>>>12][((r29+1068)>>>2)&0x3ff] = r21;
+                    writePages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1060)>>>12][((r29+1060)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1056)>>>12][((r29+1056)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1048)>>>12][((r29+1048)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x53648;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x53648:
+                    r17 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53728;
+                        continue;
+                    }
+                    r21 = 7 << 16;
+                    r22 = 7 << 16;
+                    r21 = r21 + 24472;
+                    r23 = 7 << 16;
+                    r22 = r22 + 1196;
+                    r18 = 7 << 16;
+                    r20 = 7 << 16;
+                    r19 = r21 + r0;
+                case 0x53674:
+                    r16 = r0 + 35;
+                case 0x53678:
+                    r4 = r29 + 24;
+                    r5 = r0 + 1024;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5368c;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x5368c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5371c;
+                        continue;
+                    }
+                    addr=r29+24;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53678;
+                        continue;
+                    }
+                    r2 = r23 + 30624;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = r29 + 24;
+                    r5 = r22 + r0;
+                    r6 = r21 + r0;
+                    r7 = r18 + 23448;
+                    /* Next insn is delay slot */ 
+                    r31=0x536c4;
+                    pc=0x5f000;
+                    run_5f000(); return;
+                case 0x536c4:
+                    r2 = r2 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5371c;
+                        continue;
+                    }
+                    r16 = r20 + 30616;
+                    r2 = r18 + 23448;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r4 = r30 + r0;
+                    r2 = r28 + -30620;
+                    r5 = r19 + r0;
+                    writePages[(r20+30616)>>>12][((r20+30616)>>>2)&0x3ff] = r19;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r2;
+                    writePages[(r28+-30620)>>>12][((r28+-30620)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x536fc;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x536fc:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53674;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x53710;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x53710:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5372c;
+                    continue;
+                case 0x5371c:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x53728;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x53728:
+                    r2 = r0 + r0;
+                case 0x5372c:
+                    r31 = readPages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff];
+                    r30 = readPages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff];
+                    r23 = readPages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff];
+                    r22 = readPages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff];
+                    r21 = readPages[(r29+1068)>>>12][((r29+1068)>>>2)&0x3ff];
+                    r20 = readPages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff];
+                    r19 = readPages[(r29+1060)>>>12][((r29+1060)>>>2)&0x3ff];
+                    r18 = readPages[(r29+1056)>>>12][((r29+1056)>>>2)&0x3ff];
+                    r17 = readPages[(r29+1052)>>>12][((r29+1052)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1048)>>>12][((r29+1048)>>>2)&0x3ff];
+                    r29 = r29 + 1088;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x53800:
+                    pc=0x53800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_53800() throws ExecutionException { /* 0x53800 - 0x53a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x53800:
+                    r29 = r29 + -1088;
+                    r5 = 7 << 16;
+                    writePages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff] = r23;
+                    r23 = r4 & 65535;
+                    r4 = 7 << 16;
+                    r4 = r4 + 1184;
+                    r5 = r5 + -632;
+                    writePages[(r29+1052)>>>12][((r29+1052)>>>2)&0x3ff] = r17;
+                    writePages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff] = r31;
+                    writePages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff] = r22;
+                    writePages[(r29+1068)>>>12][((r29+1068)>>>2)&0x3ff] = r21;
+                    writePages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1060)>>>12][((r29+1060)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1056)>>>12][((r29+1056)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1048)>>>12][((r29+1048)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x53848;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x53848:
+                    r17 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5391c;
+                        continue;
+                    }
+                    r20 = 7 << 16;
+                    r21 = 7 << 16;
+                    r20 = r20 + 24472;
+                    r22 = 7 << 16;
+                    r21 = r21 + 1196;
+                    r18 = 7 << 16;
+                    r19 = 7 << 16;
+                    r30 = r20 + r0;
+                case 0x53874:
+                    r16 = r0 + 35;
+                case 0x53878:
+                    r4 = r29 + 24;
+                    r5 = r0 + 1024;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5388c;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x5388c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53910;
+                        continue;
+                    }
+                    addr=r29+24;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53878;
+                        continue;
+                    }
+                    r2 = r22 + 30624;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = r29 + 24;
+                    r5 = r21 + r0;
+                    r6 = r20 + r0;
+                    r7 = r18 + 23448;
+                    /* Next insn is delay slot */ 
+                    r31=0x538c4;
+                    pc=0x5f000;
+                    run_5f000(); return;
+                case 0x538c4:
+                    r2 = r2 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53910;
+                        continue;
+                    }
+                    r16 = r19 + 30616;
+                    r2 = r18 + 23448;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r2 = r28 + -30620;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r2;
+                    addr=r16+8;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    writePages[(r19+30616)>>>12][((r19+30616)>>>2)&0x3ff] = r30;
+                    writePages[(r28+-30620)>>>12][((r28+-30620)>>>2)&0x3ff] = r0;
+                    if(r2 != r23) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53874;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x53904;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x53904:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x53920;
+                    continue;
+                case 0x53910:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5391c;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x5391c:
+                    r2 = r0 + r0;
+                case 0x53920:
+                    r31 = readPages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff];
+                    r30 = readPages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff];
+                    r23 = readPages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff];
+                    r22 = readPages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff];
+                    r21 = readPages[(r29+1068)>>>12][((r29+1068)>>>2)&0x3ff];
+                    r20 = readPages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff];
+                    r19 = readPages[(r29+1060)>>>12][((r29+1060)>>>2)&0x3ff];
+                    r18 = readPages[(r29+1056)>>>12][((r29+1056)>>>2)&0x3ff];
+                    r17 = readPages[(r29+1052)>>>12][((r29+1052)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1048)>>>12][((r29+1048)>>>2)&0x3ff];
+                    r29 = r29 + 1088;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x53a00:
+                    pc=0x53a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_53a00() throws ExecutionException { /* 0x53a00 - 0x53c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x53a00:
+                    r6 = readPages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff];
+                    r29 = r29 + -2088;
+                    writePages[(r29+2084)>>>12][((r29+2084)>>>2)&0x3ff] = r31;
+                    writePages[(r29+2080)>>>12][((r29+2080)>>>2)&0x3ff] = r17;
+                    writePages[(r29+2076)>>>12][((r29+2076)>>>2)&0x3ff] = r16;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53b0c;
+                        continue;
+                    }
+                    r4 = r29 + 1048;
+                    r5 = r0 + 1024;
+                    /* Next insn is delay slot */ 
+                    r31=0x53a2c;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x53a2c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53b0c;
+                        continue;
+                    }
+                    addr=r29+1048;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r16 = tmp;
+                    r2 = r0 + 35;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53abc;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + 30624;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = r29 + 1048;
+                case 0x53a54:
+                    r5 = 7 << 16;
+                    r17 = 7 << 16;
+                    r16 = 7 << 16;
+                    r5 = r5 + 1196;
+                    r6 = r17 + 24472;
+                    r7 = r16 + 23448;
+                    /* Next insn is delay slot */ 
+                    r31=0x53a74;
+                    pc=0x5f000;
+                    run_5f000(); return;
+                case 0x53a74:
+                    r2 = r2 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53b0c;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r17 = r17 + 24472;
+                    writePages[(r2+30616)>>>12][((r2+30616)>>>2)&0x3ff] = r17;
+                    r16 = r16 + 23448;
+                    r2 = r2 + 30616;
+                    r3 = r28 + -30620;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r16;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                    writePages[(r28+-30620)>>>12][((r28+-30620)>>>2)&0x3ff] = r0;
+                case 0x53aa4:
+                    r31 = readPages[(r29+2084)>>>12][((r29+2084)>>>2)&0x3ff];
+                    r17 = readPages[(r29+2080)>>>12][((r29+2080)>>>2)&0x3ff];
+                    r16 = readPages[(r29+2076)>>>12][((r29+2076)>>>2)&0x3ff];
+                    r29 = r29 + 2088;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x53abc:
+                    r6 = readPages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff];
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53b0c;
+                        continue;
+                    }
+                    r4 = r29 + 24;
+                    r5 = r0 + 1024;
+                    /* Next insn is delay slot */ 
+                    r31=0x53adc;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x53adc:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53b0c;
+                        continue;
+                    }
+                    addr=r29+24;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53b28;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + 30624;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x53a54;
+                    continue;
+                case 0x53b0c:
+                    r31 = readPages[(r29+2084)>>>12][((r29+2084)>>>2)&0x3ff];
+                    r17 = readPages[(r29+2080)>>>12][((r29+2080)>>>2)&0x3ff];
+                    r16 = readPages[(r29+2076)>>>12][((r29+2076)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 2088;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x53b28:
+                    /* Next insn is delay slot */ 
+                    r31=0x53b30;
+                    pc=0x53a00;
+                    continue;
+                case 0x53b30:
+                    /* Next insn is delay slot */ 
+                    pc=0x53aa4;
+                    continue;
+                case 0x53c00:
+                    pc=0x53c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_53c00() throws ExecutionException { /* 0x53c00 - 0x53e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x53c00:
+                    r4 = readPages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53c1c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x53c1c;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x53c1c:
+                    r4 = 7 << 16;
+                    r5 = 7 << 16;
+                    r4 = r4 + 1184;
+                    r5 = r5 + -632;
+                    /* Next insn is delay slot */ 
+                    r31=0x53c34;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x53c34:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff] = r2;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x53e00:
+                    pc=0x53e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_53e00() throws ExecutionException { /* 0x53e00 - 0x54000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x53e00:
+                    r4 = readPages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x53e1c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x53e1c;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x53e1c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff] = r0;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x54000:
+                    pc=0x54000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_54000() throws ExecutionException { /* 0x54000 - 0x54200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x54000:
+                    r29 = r29 + -1104;
+                    r5 = 7 << 16;
+                    writePages[(r29+1104)>>>12][((r29+1104)>>>2)&0x3ff] = r4;
+                    r4 = 7 << 16;
+                    r4 = r4 + 1212;
+                    r5 = r5 + -632;
+                    writePages[(r29+1068)>>>12][((r29+1068)>>>2)&0x3ff] = r17;
+                    writePages[(r29+1100)>>>12][((r29+1100)>>>2)&0x3ff] = r31;
+                    writePages[(r29+1096)>>>12][((r29+1096)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1092)>>>12][((r29+1092)>>>2)&0x3ff] = r23;
+                    writePages[(r29+1088)>>>12][((r29+1088)>>>2)&0x3ff] = r22;
+                    writePages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff] = r21;
+                    writePages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x54048;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x54048:
+                    r17 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54160;
+                        continue;
+                    }
+                    r20 = 7 << 16;
+                    r20 = r20 + 29592;
+                    r19 = 7 << 16;
+                    r18 = r20 + r0;
+                case 0x54064:
+                    r16 = r0 + 35;
+                case 0x54068:
+                    r4 = r29 + 40;
+                    r5 = r0 + 1024;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5407c;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x5407c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54154;
+                        continue;
+                    }
+                    addr=r29+40;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54068;
+                        continue;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r3 + 30640;
+                    r3 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r22 = r3 + 27544;
+                    r8 = 7 << 16;
+                    r3 = 7 << 16;
+                    r2 = 7 << 16;
+                    r2 = r2 + 30642;
+                    r21 = r8 + 26520;
+                    r30 = r3 + 25496;
+                    r5 = 7 << 16;
+                    r23 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r22;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r30;
+                    r4 = r29 + 40;
+                    r5 = r5 + 1224;
+                    r6 = r20 + r0;
+                    r7 = r23 + 28568;
+                    /* Next insn is delay slot */ 
+                    r31=0x540f0;
+                    pc=0x5f000;
+                    run_5f000(); return;
+                case 0x540f0:
+                    r2 = r2 < 7 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54154;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r4 = readPages[(r29+1104)>>>12][((r29+1104)>>>2)&0x3ff];
+                    r16 = r19 + 30632;
+                    r10 = r23 + 28568;
+                    r2 = r2 + -12264;
+                    r5 = r18 + r0;
+                    writePages[(r19+30632)>>>12][((r19+30632)>>>2)&0x3ff] = r18;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r10;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r22;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r21;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r30;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x54134;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x54134:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54064;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x54148;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x54148:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x54164;
+                    continue;
+                case 0x54154:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x54160;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x54160:
+                    r2 = r0 + r0;
+                case 0x54164:
+                    r31 = readPages[(r29+1100)>>>12][((r29+1100)>>>2)&0x3ff];
+                    r30 = readPages[(r29+1096)>>>12][((r29+1096)>>>2)&0x3ff];
+                    r23 = readPages[(r29+1092)>>>12][((r29+1092)>>>2)&0x3ff];
+                    r22 = readPages[(r29+1088)>>>12][((r29+1088)>>>2)&0x3ff];
+                    r21 = readPages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff];
+                    r20 = readPages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff];
+                    r19 = readPages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff];
+                    r18 = readPages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff];
+                    r17 = readPages[(r29+1068)>>>12][((r29+1068)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff];
+                    r29 = r29 + 1104;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x54200:
+                    pc=0x54200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_54200() throws ExecutionException { /* 0x54200 - 0x54400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x54200:
+                    r29 = r29 + -1112;
+                    r4 = r4 & 65535;
+                    r5 = 7 << 16;
+                    writePages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff] = r4;
+                    r4 = 7 << 16;
+                    r4 = r4 + 1212;
+                    r5 = r5 + -632;
+                    writePages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff] = r17;
+                    writePages[(r29+1108)>>>12][((r29+1108)>>>2)&0x3ff] = r31;
+                    writePages[(r29+1104)>>>12][((r29+1104)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1100)>>>12][((r29+1100)>>>2)&0x3ff] = r23;
+                    writePages[(r29+1096)>>>12][((r29+1096)>>>2)&0x3ff] = r22;
+                    writePages[(r29+1092)>>>12][((r29+1092)>>>2)&0x3ff] = r21;
+                    writePages[(r29+1088)>>>12][((r29+1088)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x5424c;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x5424c:
+                    r17 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54360;
+                        continue;
+                    }
+                    r19 = 7 << 16;
+                    r22 = 7 << 16;
+                    r19 = r19 + 29592;
+                    r18 = 7 << 16;
+                case 0x54268:
+                    r16 = r0 + 35;
+                case 0x5426c:
+                    r4 = r29 + 40;
+                    r5 = r0 + 1024;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x54280;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x54280:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54354;
+                        continue;
+                    }
+                    addr=r29+40;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5426c;
+                        continue;
+                    }
+                    r2 = r22 + 30640;
+                    r3 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r20 = r3 + 27544;
+                    r8 = 7 << 16;
+                    r3 = 7 << 16;
+                    r2 = 7 << 16;
+                    r2 = r2 + 30642;
+                    r23 = r8 + 26520;
+                    r30 = r3 + 25496;
+                    r5 = 7 << 16;
+                    r21 = 7 << 16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r23;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r30;
+                    r4 = r29 + 40;
+                    r5 = r5 + 1224;
+                    r6 = r19 + r0;
+                    r7 = r21 + 28568;
+                    /* Next insn is delay slot */ 
+                    r31=0x542f0;
+                    pc=0x5f000;
+                    run_5f000(); return;
+                case 0x542f0:
+                    r2 = r2 < 7 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54354;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + 29592;
+                    writePages[(r18+30632)>>>12][((r18+30632)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r16 = r18 + 30632;
+                    r2 = r2 + -12264;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r2;
+                    r3 = readPages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff];
+                    addr=r16+8;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r10 = r21 + 28568;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r10;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r20;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r23;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r30;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54268;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x54348;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x54348:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x54364;
+                    continue;
+                case 0x54354:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x54360;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x54360:
+                    r2 = r0 + r0;
+                case 0x54364:
+                    r31 = readPages[(r29+1108)>>>12][((r29+1108)>>>2)&0x3ff];
+                    r30 = readPages[(r29+1104)>>>12][((r29+1104)>>>2)&0x3ff];
+                    r23 = readPages[(r29+1100)>>>12][((r29+1100)>>>2)&0x3ff];
+                    r22 = readPages[(r29+1096)>>>12][((r29+1096)>>>2)&0x3ff];
+                    r21 = readPages[(r29+1092)>>>12][((r29+1092)>>>2)&0x3ff];
+                    r20 = readPages[(r29+1088)>>>12][((r29+1088)>>>2)&0x3ff];
+                    r19 = readPages[(r29+1084)>>>12][((r29+1084)>>>2)&0x3ff];
+                    r18 = readPages[(r29+1080)>>>12][((r29+1080)>>>2)&0x3ff];
+                    r17 = readPages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1072)>>>12][((r29+1072)>>>2)&0x3ff];
+                    r29 = r29 + 1112;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x54400:
+                    pc=0x54400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_54400() throws ExecutionException { /* 0x54400 - 0x54600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x54400:
+                    r6 = readPages[(r28+-30612)>>>12][((r28+-30612)>>>2)&0x3ff];
+                    r29 = r29 + -2112;
+                    writePages[(r29+2108)>>>12][((r29+2108)>>>2)&0x3ff] = r31;
+                    writePages[(r29+2104)>>>12][((r29+2104)>>>2)&0x3ff] = r20;
+                    writePages[(r29+2100)>>>12][((r29+2100)>>>2)&0x3ff] = r19;
+                    writePages[(r29+2096)>>>12][((r29+2096)>>>2)&0x3ff] = r18;
+                    writePages[(r29+2092)>>>12][((r29+2092)>>>2)&0x3ff] = r17;
+                    writePages[(r29+2088)>>>12][((r29+2088)>>>2)&0x3ff] = r16;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54590;
+                        continue;
+                    }
+                    r4 = r29 + 1064;
+                    r5 = r0 + 1024;
+                    /* Next insn is delay slot */ 
+                    r31=0x54438;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x54438:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54590;
+                        continue;
+                    }
+                    addr=r29+1064;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r16 = tmp;
+                    r2 = r0 + 35;
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54510;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + 30640;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r18 = 7 << 16;
+                    r2 = 7 << 16;
+                    r17 = 7 << 16;
+                    r16 = 7 << 16;
+                    r2 = r2 + 30642;
+                    r18 = r18 + 27544;
+                    r17 = r17 + 26520;
+                    r16 = r16 + 25496;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r16;
+                    r4 = r29 + 1064;
+                case 0x54490:
+                    r5 = 7 << 16;
+                    r20 = 7 << 16;
+                    r19 = 7 << 16;
+                    r5 = r5 + 1224;
+                    r6 = r20 + 29592;
+                    r7 = r19 + 28568;
+                    /* Next insn is delay slot */ 
+                    r31=0x544b0;
+                    pc=0x5f000;
+                    run_5f000(); return;
+                case 0x544b0:
+                    r2 = r2 < 7 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54590;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r20 = r20 + 29592;
+                    r3 = 7 << 16;
+                    writePages[(r2+30632)>>>12][((r2+30632)>>>2)&0x3ff] = r20;
+                    r19 = r19 + 28568;
+                    r2 = r2 + 30632;
+                    r3 = r3 + -12264;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r19;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r18;
+                    writePages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff] = r17;
+                    writePages[(r2+24)>>>12][((r2+24)>>>2)&0x3ff] = r16;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r3;
+                case 0x544ec:
+                    r31 = readPages[(r29+2108)>>>12][((r29+2108)>>>2)&0x3ff];
+                    r20 = readPages[(r29+2104)>>>12][((r29+2104)>>>2)&0x3ff];
+                    r19 = readPages[(r29+2100)>>>12][((r29+2100)>>>2)&0x3ff];
+                    r18 = readPages[(r29+2096)>>>12][((r29+2096)>>>2)&0x3ff];
+                    r17 = readPages[(r29+2092)>>>12][((r29+2092)>>>2)&0x3ff];
+                    r16 = readPages[(r29+2088)>>>12][((r29+2088)>>>2)&0x3ff];
+                    r29 = r29 + 2112;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x54510:
+                    r6 = readPages[(r28+-30612)>>>12][((r28+-30612)>>>2)&0x3ff];
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54590;
+                        continue;
+                    }
+                    r4 = r29 + 40;
+                    r5 = r0 + 1024;
+                    /* Next insn is delay slot */ 
+                    r31=0x54530;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x54530:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54590;
+                        continue;
+                    }
+                    addr=r29+40;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x545b8;
+                        continue;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + 30640;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r18 = 7 << 16;
+                    r2 = 7 << 16;
+                    r17 = 7 << 16;
+                    r16 = 7 << 16;
+                    r2 = r2 + 30642;
+                    r18 = r18 + 27544;
+                    r17 = r17 + 26520;
+                    r16 = r16 + 25496;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r16;
+                    r4 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=0x54490;
+                    continue;
+                case 0x54590:
+                    r31 = readPages[(r29+2108)>>>12][((r29+2108)>>>2)&0x3ff];
+                    r20 = readPages[(r29+2104)>>>12][((r29+2104)>>>2)&0x3ff];
+                    r19 = readPages[(r29+2100)>>>12][((r29+2100)>>>2)&0x3ff];
+                    r18 = readPages[(r29+2096)>>>12][((r29+2096)>>>2)&0x3ff];
+                    r17 = readPages[(r29+2092)>>>12][((r29+2092)>>>2)&0x3ff];
+                    r16 = readPages[(r29+2088)>>>12][((r29+2088)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 2112;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x545b8:
+                    /* Next insn is delay slot */ 
+                    r31=0x545c0;
+                    pc=0x54400;
+                    continue;
+                case 0x545c0:
+                    /* Next insn is delay slot */ 
+                    pc=0x544ec;
+                    continue;
+                case 0x54600:
+                    pc=0x54600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_54600() throws ExecutionException { /* 0x54600 - 0x54800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x54600:
+                    r4 = readPages[(r28+-30612)>>>12][((r28+-30612)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5461c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x5461c;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x5461c:
+                    r4 = 7 << 16;
+                    r5 = 7 << 16;
+                    r4 = r4 + 1184;
+                    r5 = r5 + -632;
+                    /* Next insn is delay slot */ 
+                    r31=0x54634;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x54634:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30612)>>>12][((r28+-30612)>>>2)&0x3ff] = r2;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x54800:
+                    pc=0x54800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_54800() throws ExecutionException { /* 0x54800 - 0x54a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x54800:
+                    r4 = readPages[(r28+-30612)>>>12][((r28+-30612)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5481c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x5481c;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x5481c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30612)>>>12][((r28+-30612)>>>2)&0x3ff] = r0;
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x54a00:
+                    pc=0x54a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_54a00() throws ExecutionException { /* 0x54a00 - 0x54c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x54a00:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    r5 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x54a20;
+                    pc=0x59a00;
+                    run_59a00(); return;
+                case 0x54a20:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r16 = 7 << 16;
+                    r4 = readPages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x54a34;
+                    pc=0x39a00;
+                    run_39a00(); return;
+                case 0x54a34:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r4 = r16 + 20056;
+                    r6 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r5 = r0 + 1024;
+                    /* Next insn is delay slot */ 
+                    r31=0x54a4c;
+                    pc=0x59400;
+                    run_59400(); return;
+                case 0x54a4c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54ab8;
+                        continue;
+                    }
+                    r4 = r16 + 20056;
+                    /* Next insn is delay slot */ 
+                    r31=0x54a60;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x54a60:
+                    r17 = r2 + -1;
+                    r16 = r16 + 20056;
+                    r3 = r16 + r17;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r0 + 10;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54a80;
+                        continue;
+                    }
+                    r17 = r2 + r0;
+                case 0x54a80:
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r17 = r16 + r17;
+                    r5 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r0 + 10;
+                    /* Next insn is delay slot */ 
+                    r31=0x54a98;
+                    pc=0x3c000;
+                    run_3c000(); return;
+                case 0x54a98:
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x54ab8:
+                    r17 = r0 + r0;
+                    r16 = r16 + 20056;
+                    /* Next insn is delay slot */ 
+                    pc=0x54a80;
+                    continue;
+                case 0x54c00:
+                    pc=0x54c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_54c00() throws ExecutionException { /* 0x54c00 - 0x54e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x54c00:
+                    r29 = r29 + -32;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    r4 = r0 + 128;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r18 = r5 + r0;
+                    r17 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x54c2c;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x54c2c:
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54cbc;
+                        continue;
+                    }
+                    r4 = r2 + r0;
+                    r5 = r0 + 128;
+                    r6 = r18 + r0;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x54c50;
+                    pc=0x64e00;
+                    run_64e00(); return;
+                case 0x54c50:
+                    r3 = r2 < 128 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54c78;
+                        continue;
+                    }
+                case 0x54c5c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x54c78:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r5 = r2 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x54c88;
+                    pc=0x40600;
+                    run_40600(); return;
+                case 0x54c88:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x54cc8;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r5 = r18 + r0;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r6 = r17 + r0;
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x65200;
+                    run_65200(); return;
+                case 0x54cbc:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x54c5c;
+                    continue;
+                case 0x54cc8:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x54cd4;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x54cd4:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x54c5c;
+                    continue;
+                case 0x54e00:
+                    pc=0x54e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_54e00() throws ExecutionException { /* 0x54e00 - 0x55000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x54e00:
+                    r4 = 7 << 16;
+                    r4 = r4 + 1260;
+                    /* Next insn is delay slot */ 
+                    pc=0x3e000;
+                    run_3e000(); return;
+                case 0x55000:
+                    pc=0x55000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_55000() throws ExecutionException { /* 0x55000 - 0x55200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x55000:
+                    r29 = r29 + -32;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r16 = r4 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x550b4;
+                        continue;
+                    }
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x550b4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x55038;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x55038:
+                    r2 = r2 + -1;
+                    r2 = r16 + r2;
+                    r3 = ((r16 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5510c;
+                        continue;
+                    }
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r0 + 47;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x550e0;
+                        continue;
+                    }
+                    r4 = r0 + 47;
+                    /* Next insn is delay slot */ 
+                    pc=0x55078;
+                    continue;
+                case 0x55068:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x550e0;
+                        continue;
+                    }
+                case 0x55078:
+                    r2 = r2 + -1;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55068;
+                        continue;
+                    }
+                case 0x55084:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 47;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x551b4;
+                        continue;
+                    }
+                    r3 = 7 << 16;
+                    r3 = r3 + -9052;
+                case 0x5509c:
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r2 = 7 << 16;
+                    addr=r2+19032;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r2 + 19032;
+                    /* Next insn is delay slot */ 
+                    pc=0x550c4;
+                    continue;
+                case 0x550b4:
+                    r2 = 7 << 16;
+                    r3 = r0 + 11776;
+                    addr=r2+19032;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r2 + 19032;
+                case 0x550c4:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x550e0:
+                    r4 = r0 + 47;
+                    /* Next insn is delay slot */ 
+                    pc=0x550fc;
+                    continue;
+                case 0x550ec:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5510c;
+                        continue;
+                    }
+                case 0x550fc:
+                    r2 = r2 + -1;
+                    r3 = ((r16 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x550ec;
+                        continue;
+                    }
+                case 0x5510c:
+                    r4 = r0 + 47;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55130;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x55084;
+                    continue;
+                case 0x55120:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55140;
+                        continue;
+                    }
+                case 0x55130:
+                    r2 = r2 + -1;
+                    r3 = ((r16 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55120;
+                        continue;
+                    }
+                case 0x55140:
+                    r2 = r2 - r16;
+                    r3 = r2 + 2;
+                    r3 = (r3&0xffffffffL) < (1025&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55198;
+                        continue;
+                    }
+                    r17 = r2 + 1;
+                    r18 = 7 << 16;
+                    r4 = r18 + 19032;
+                    r5 = r16 + r0;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55170;
+                    pc=0x5f400;
+                    run_5f400(); return;
+                case 0x55170:
+                    r2 = r18 + 19032;
+                    r17 = r17 + r2;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x55198:
+                    /* Next insn is delay slot */ 
+                    r31=0x551a0;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x551a0:
+                    r3 = r0 + 91;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x550c4;
+                    continue;
+                case 0x551b4:
+                    r3 = 7 << 16;
+                    r3 = r3 + 1268;
+                    /* Next insn is delay slot */ 
+                    pc=0x5509c;
+                    continue;
+                case 0x55200:
+                    pc=0x55200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_55200() throws ExecutionException { /* 0x55200 - 0x55400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x55200:
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r16 = r4 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5534c;
+                        continue;
+                    }
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5534c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x55234;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x55234:
+                    r2 = r2 + -1;
+                    r2 = r16 + r2;
+                    r3 = ((r16 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5538c;
+                        continue;
+                    }
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r0 + 47;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x552e0;
+                        continue;
+                    }
+                    r4 = r0 + 47;
+                    /* Next insn is delay slot */ 
+                    pc=0x55274;
+                    continue;
+                case 0x55264:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x552d4;
+                        continue;
+                    }
+                case 0x55274:
+                    r2 = r2 + -1;
+                    if(r2 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55264;
+                        continue;
+                    }
+                case 0x55280:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r0 + 47;
+                    if(r4 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55374;
+                        continue;
+                    }
+                case 0x55290:
+                    r5 = r2 + r0;
+                    r2 = r0 + r0;
+                case 0x55298:
+                    r16 = r2 + 1;
+                    r17 = 7 << 16;
+                    r6 = r16 + r0;
+                    r4 = r17 + 18008;
+                    /* Next insn is delay slot */ 
+                    r31=0x552b0;
+                    pc=0x5f400;
+                    run_5f400(); return;
+                case 0x552b0:
+                    r2 = r17 + 18008;
+                    r16 = r16 + r2;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x552bc:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x552d4:
+                    r3 = ((r16 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55290;
+                        continue;
+                    }
+                case 0x552e0:
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r6 = tmp;
+                    r3 = r0 + 47;
+                    r5 = r2 + r0;
+                    r4 = r0 + 47;
+                    if(r6 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55310;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x55290;
+                    continue;
+                case 0x55300:
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5531c;
+                        continue;
+                    }
+                case 0x55310:
+                    r5 = r5 + -1;
+                    if(r5 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55300;
+                        continue;
+                    }
+                case 0x5531c:
+                    r2 = r2 - r5;
+                    r3 = r2 + 2;
+                    r3 = (r3&0xffffffffL) < (1025&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55298;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x55338;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55338:
+                    r3 = r0 + 91;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x552bc;
+                    continue;
+                case 0x5534c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r3 = r0 + 11776;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    addr=r2+18008;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r2 + 18008;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x55374:
+                    r2 = 7 << 16;
+                    r3 = r0 + 12032;
+                    addr=r2+18008;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r2 + 18008;
+                    /* Next insn is delay slot */ 
+                    pc=0x552bc;
+                    continue;
+                case 0x5538c:
+                    if(r16 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55280;
+                        continue;
+                    }
+                    r5 = r2 + r0;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x55298;
+                    continue;
+                case 0x55400:
+                    pc=0x55400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_55400() throws ExecutionException { /* 0x55400 - 0x55600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x55400:
+                    r29 = r29 + -72;
+                    r2 = r0 + 1;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 32;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r18;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r17;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r16;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r31;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r20;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r19;
+                    r17 = r4 + r0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x5543c;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x5543c:
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 8;
+                    r16 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55498;
+                        continue;
+                    }
+                    r4 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r5 = r5 + 1096;
+                    /* Next insn is delay slot */ 
+                    r31=0x5546c;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x5546c:
+                    r2 = r0 + 22;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x55474:
+                    /* Next insn is delay slot */ 
+                    r31=0x5547c;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x5547c:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 12;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5585c;
+                        run_55800(); return;
+                    }
+                    r18 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x554d0;
+                    continue;
+                case 0x55498:
+                    r2 = r29 + 40;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                    r4 = r16 + r0;
+                    r5 = r29 + 32;
+                    r6 = r0 + 2;
+                    r7 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x554c0;
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x554c0:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55474;
+                        continue;
+                    }
+                case 0x554cc:
+                    r18 = r0 + r0;
+                case 0x554d0:
+                    r2 = r0 + 1;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 10;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    addr=r17+31;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 32;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x554f4;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x554f4:
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 8;
+                    r16 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55550;
+                        continue;
+                    }
+                    r4 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r5 = r5 + 1096;
+                    /* Next insn is delay slot */ 
+                    r31=0x55524;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x55524:
+                    r2 = r0 + 22;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x5552c:
+                    /* Next insn is delay slot */ 
+                    r31=0x55534;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55534:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 12;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55870;
+                        run_55800(); return;
+                    }
+                    r18 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x55584;
+                    continue;
+                case 0x55550:
+                    r2 = r29 + 40;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                    r4 = r16 + r0;
+                    r5 = r29 + 32;
+                    r6 = r0 + 2;
+                    r7 = r17 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x55578;
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x55578:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5552c;
+                        continue;
+                    }
+                case 0x55584:
+                    r2 = r0 + 1;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    addr=r17+63;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 32;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x555a8;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x555a8:
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 8;
+                    r16 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55604;
+                        run_55600(); return;
+                    }
+                    r4 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r5 = r5 + 1096;
+                    /* Next insn is delay slot */ 
+                    r31=0x555d8;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x555d8:
+                    r2 = r0 + 22;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x555e0:
+                    /* Next insn is delay slot */ 
+                    r31=0x555e8;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x555e8:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 12;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55884;
+                        run_55800(); return;
+                    }
+                    r18 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x55638;
+                    run_55600(); return;
+                case 0x55600:
+                    pc=0x55600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_55600() throws ExecutionException { /* 0x55600 - 0x55800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x55600:
+                case 0x55604:
+                    r2 = r29 + 40;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                    r4 = r16 + r0;
+                    r5 = r29 + 32;
+                    r6 = r0 + 2;
+                    r7 = r17 + 64;
+                    /* Next insn is delay slot */ 
+                    r31=0x5562c;
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x5562c:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x555e0;
+                        run_55400(); return;
+                    }
+                case 0x55638:
+                    r2 = r0 + 1;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 4;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    addr=r17+95;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 32;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x5565c;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x5565c:
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r20 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 8;
+                    r16 = r17 + 96;
+                    r19 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x556bc;
+                        continue;
+                    }
+                    r4 = readPages[(r19+12)>>>12][((r19+12)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r5 = r5 + 1096;
+                    /* Next insn is delay slot */ 
+                    r31=0x55690;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x55690:
+                    r2 = r0 + 22;
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r2;
+                case 0x55698:
+                    /* Next insn is delay slot */ 
+                    r31=0x556a0;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x556a0:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 12;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55898;
+                        run_55800(); return;
+                    }
+                    r18 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x556f0;
+                    continue;
+                case 0x556bc:
+                    r2 = r29 + 40;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                    r4 = r19 + r0;
+                    r5 = r29 + 32;
+                    r6 = r0 + 2;
+                    r7 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x556e4;
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x556e4:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55698;
+                        continue;
+                    }
+                case 0x556f0:
+                    r2 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    addr=r17+127;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r2 + -1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55760;
+                        continue;
+                    }
+                    r4 = r0 + 32;
+                    r6 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x55724;
+                    continue;
+                case 0x55714:
+                    r3 = r3 + -1;
+                    r16 = r16 + 1;
+                    if(r3 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55760;
+                        continue;
+                    }
+                case 0x55724:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r5 = tmp;
+                    r5 = r5 + -9;
+                    r5 = r5 & 255;
+                    r5 = (r5&0xffffffffL) < (2&0xffffffffL) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55714;
+                        continue;
+                    }
+                    r2 = (r3&0xffffffffL) < (2&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x557e4;
+                        continue;
+                    }
+                    r3 = r3 + -1;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r16 = r16 + 1;
+                    if(r3 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55724;
+                        continue;
+                    }
+                case 0x55760:
+                    r2 = r0 + 6;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 32;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x55780;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55780:
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 8;
+                    r16 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x557f0;
+                        continue;
+                    }
+                    r4 = readPages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff];
+                    r5 = 7 << 16;
+                    r6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r5 = r5 + 1096;
+                    /* Next insn is delay slot */ 
+                    r31=0x557b0;
+                    pc=0x3bc00;
+                    run_3bc00(); return;
+                case 0x557b0:
+                    r2 = r0 + 22;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                case 0x557b8:
+                    /* Next insn is delay slot */ 
+                    r31=0x557c0;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x557c0:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r0 + 12;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55850;
+                        run_55800(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x557d8;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x557d8:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r19;
+                    /* Next insn is delay slot */ 
+                    pc=0x55824;
+                    run_55800(); return;
+                case 0x557e4:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x55714;
+                    continue;
+                case 0x557f0:
+                    r2 = r29 + 40;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                case 0x55800:
+                    pc=0x55800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_55800() throws ExecutionException { /* 0x55800 - 0x55a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x55800:
+                    r4 = r16 + r0;
+                    r5 = r29 + 32;
+                    r6 = r0 + 2;
+                    r7 = r17 + 128;
+                    /* Next insn is delay slot */ 
+                    r31=0x55818;
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x55818:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x557b8;
+                        run_55600(); return;
+                    }
+                case 0x55824:
+                    r31 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r2 = r18 + r0;
+                    r20 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r19 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r18 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r16 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    addr=r17+159;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r17 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r29 = r29 + 72;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x55850:
+                    r18 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x55824;
+                    continue;
+                case 0x5585c:
+                    /* Next insn is delay slot */ 
+                    r31=0x55864;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55864:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x554cc;
+                    run_55400(); return;
+                case 0x55870:
+                    /* Next insn is delay slot */ 
+                    r31=0x55878;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55878:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r19;
+                    /* Next insn is delay slot */ 
+                    pc=0x55584;
+                    run_55400(); return;
+                case 0x55884:
+                    /* Next insn is delay slot */ 
+                    r31=0x5588c;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x5588c:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r19;
+                    /* Next insn is delay slot */ 
+                    pc=0x55638;
+                    run_55600(); return;
+                case 0x55898:
+                    /* Next insn is delay slot */ 
+                    r31=0x558a0;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x558a0:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r20;
+                    /* Next insn is delay slot */ 
+                    pc=0x556f0;
+                    run_55600(); return;
+                case 0x55a00:
+                    pc=0x55a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_55a00() throws ExecutionException { /* 0x55a00 - 0x55c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x55a00:
+                    r29 = r29 + -56;
+                    r2 = r0 + 1;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 10;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r7 = r4 + r0;
+                    r2 = r29 + 40;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r5;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r0;
+                    r5 = r29 + 32;
+                    r6 = r0 + 2;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x55a44;
+                    pc=0x4928c;
+                    run_49200(); return;
+                case 0x55a44:
+                    r2 = r2 + 1;
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = (r2&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r2 = r0 - r2;
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x55c00:
+                    pc=0x55c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_55c00() throws ExecutionException { /* 0x55c00 - 0x55e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x55c00:
+                    r29 = r29 + -40;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    r19 = r4 + r0;
+                    r18 = r5 + r0;
+                    r17 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    r31=0x55c2c;
+                    pc=0x62c00;
+                    run_62c00(); return;
+                case 0x55c2c:
+                    r16 = r2 + r0;
+                    if(r2 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55c64;
+                        continue;
+                    }
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55c88;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x55c4c;
+                    pc=0x49ab4;
+                    run_49a00(); return;
+                case 0x55c4c:
+                    if(r2 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55d3c;
+                        continue;
+                    }
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55d18;
+                        continue;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55c94;
+                        continue;
+                    }
+                case 0x55c64:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x55c88:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55c94;
+                    pc=0x48800;
+                    run_48800(); return;
+                case 0x55c94:
+                    r4 = 7 << 16;
+                    r4 = r4 + 1272;
+                    r5 = r0 + 2;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55cac;
+                    pc=0x63000;
+                    run_63000(); return;
+                case 0x55cac:
+                    r17 = r2 + r0;
+                    r2 = r0 + -1;
+                    if(r17 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55c64;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r17 + r0;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55cd0;
+                    pc=0x48c90;
+                    run_48c00(); return;
+                case 0x55cd0:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r17 + r0;
+                    r6 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x55ce4;
+                    pc=0x48c90;
+                    run_48c00(); return;
+                case 0x55ce4:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r17 + r0;
+                    r6 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    r31=0x55cf8;
+                    pc=0x48c90;
+                    run_48c00(); return;
+                case 0x55cf8:
+                    r2 = r17 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55c64;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55d10;
+                    pc=0x62a00;
+                    run_62a00(); return;
+                case 0x55d10:
+                    /* Next insn is delay slot */ 
+                    pc=0x55c64;
+                    continue;
+                case 0x55d18:
+                    r5 = 7 << 16;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r5 + 1268;
+                    /* Next insn is delay slot */ 
+                    r31=0x55d2c;
+                    pc=0x48c10;
+                    run_48c00(); return;
+                case 0x55d2c:
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55c64;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x55c94;
+                    continue;
+                case 0x55d3c:
+                    r16 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x55c64;
+                    continue;
+                case 0x55e00:
+                    pc=0x55e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_55e00() throws ExecutionException { /* 0x55e00 - 0x56000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x55e00:
+                    r29 = r29 + -80;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r31;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r23;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r22;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r21;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r20;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r19;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r18;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r17;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r16;
+                    r23 = r4 + r0;
+                    r22 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55e38;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55e38:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    r4 = r23 + r0;
+                    r5 = r29 + 32;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55e50;
+                    pc=0x5fc00;
+                    run_5fc00(); return;
+                case 0x55e50:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55e5c;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55e5c:
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r18 = r0 + 34;
+                    r17 = r29 + 16;
+                    r19 = r0 + r0;
+                    r20 = r0 + 46;
+                    r21 = r0 + 3;
+                    if(r2 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                case 0x55e7c:
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    if(r3 == r23) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55f44;
+                        continue;
+                    }
+                    if(r4 != r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55f24;
+                        continue;
+                    }
+                    r17 = r17 + 4;
+                    if(r19 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                    r23 = r3 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x55ebc;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55ebc:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    r4 = r23 + r0;
+                    r5 = r29 + 32;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55ed4;
+                    pc=0x5fc00;
+                    run_5fc00(); return;
+                case 0x55ed4:
+                    r16 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x55ee0;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x55ee0:
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r19 = r19 + 1;
+                    if(r2 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55e7c;
+                        continue;
+                    }
+                case 0x55ef0:
+                    r2 = r0 + r0;
+                case 0x55ef4:
+                    r31 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r23 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r22 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r21 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r20 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r19 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r18 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r17 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r16 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r29 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x55f24:
+                    r2 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r4 = r4 & 255;
+                    r4 = r2 + r4;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                case 0x55f44:
+                    r2 = r0 + 2;
+                    if(r19 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55fe8;
+                        continue;
+                    }
+                    r2 = r0 + 3;
+                    if(r19 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55f80;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    if(r19 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56038;
+                        run_56000(); return;
+                    }
+                case 0x55f68:
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5606c;
+                        run_56000(); return;
+                    }
+                    writePages[(r22+0)>>>12][((r22+0)>>>2)&0x3ff] = r16;
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x55ef4;
+                    continue;
+                case 0x55f80:
+                    r2 = (r16&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                    r4 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = (r4&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = (r3&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                    r4 = r4 << 16;
+                    r2 = r2 << 24;
+                    r2 = r4 | r2;
+                    r3 = r3 << 8;
+                    r2 = r2 | r3;
+                    r16 = r2 | r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x55f68;
+                    continue;
+                case 0x55fe8:
+                    r2 = 1 << 16;
+                    r2 = ((r16 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        continue;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x56000:
+                    pc=0x56000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_56000() throws ExecutionException { /* 0x56000 - 0x56200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x56000:
+                    r3 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        run_55e00(); return;
+                    }
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = (r3&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        run_55e00(); return;
+                    }
+                    r3 = r3 << 16;
+                    r2 = r2 << 24;
+                    r2 = r3 | r2;
+                    r16 = r2 | r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x55f68;
+                    run_55e00(); return;
+                case 0x56038:
+                    r2 = 256 << 16;
+                    r2 = ((r16 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        run_55e00(); return;
+                    }
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = (r2&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x55ef0;
+                        run_55e00(); return;
+                    }
+                    r2 = r2 << 24;
+                    r16 = r16 | r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x55f68;
+                    run_55e00(); return;
+                case 0x5606c:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x55ef4;
+                    run_55e00(); return;
+                case 0x56200:
+                    pc=0x56200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_56200() throws ExecutionException { /* 0x56200 - 0x56400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x56200:
+                    r29 = r29 + -32;
+                    r5 = r29 + 16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x56214;
+                    pc=0x55e00;
+                    run_55e00(); return;
+                case 0x56214:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56230;
+                        continue;
+                    }
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x56230:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x56400:
+                    pc=0x56400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_56400() throws ExecutionException { /* 0x56400 - 0x56600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x56400:
+                    r29 = r29 + -56;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r20;
+                    r20 = readPages[(r7+0)>>>12][((r7+0)>>>2)&0x3ff];
+                    r5 = r5 & 65535;
+                    r2 = r20 < 2 ? 1 : 0;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r22;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r23;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r21;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r17 = r4 + r0;
+                    r19 = r6 + r0;
+                    r22 = r7 + r0;
+                    addr=r6+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r5&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x565cc;
+                        continue;
+                    }
+                    addr=r6+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r5&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r16 = r0 + 2;
+                case 0x56454:
+                    r4 = readPages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5646c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x5646c;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x5646c:
+                    r4 = 7 << 16;
+                    r5 = 7 << 16;
+                    r4 = r4 + 1184;
+                    r5 = r5 + -632;
+                    /* Next insn is delay slot */ 
+                    r31=0x56484;
+                    pc=0x3b800;
+                    run_3b800(); return;
+                case 0x56484:
+                    writePages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff] = r2;
+                    r21 = r0 + r0;
+                case 0x5648c:
+                    /* Next insn is delay slot */ 
+                    r31=0x56494;
+                    pc=0x53a00;
+                    run_53a00(); return;
+                case 0x56494:
+                    r18 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5656c;
+                        continue;
+                    }
+                case 0x564a0:
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x564ec;
+                        continue;
+                    }
+                    addr=r2+8;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r4 = tmp;
+                    addr=r19+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5648c;
+                        continue;
+                    }
+                    r8 = r19 + 2;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x564e0;
+                    continue;
+                case 0x564cc:
+                    r8 = r8 + 2;
+                    addr=r8+-2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5648c;
+                        continue;
+                    }
+                case 0x564e0:
+                    r3 = r3 + 1;
+                    if(r3 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x564cc;
+                        continue;
+                    }
+                case 0x564ec:
+                    r23 = readPages[(r18+12)>>>12][((r18+12)>>>2)&0x3ff];
+                    r4 = readPages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5648c;
+                        continue;
+                    }
+                    r23 = r23 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x56524;
+                    continue;
+                case 0x56510:
+                    r23 = r23 + 4;
+                    r4 = readPages[(r23+-4)>>>12][((r23+-4)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5648c;
+                        continue;
+                    }
+                case 0x56524:
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x56530;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x56530:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56510;
+                        continue;
+                    }
+                    r2 = r16 < r20 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x565c0;
+                        continue;
+                    }
+                    addr=r18+8;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r3 = tmp;
+                    r2 = r16 << 1;
+                    r2 = r19 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x5655c;
+                    pc=0x53a00;
+                    run_53a00(); return;
+                case 0x5655c:
+                    r16 = r16 + 1;
+                    r18 = r2 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x564a0;
+                        continue;
+                    }
+                case 0x5656c:
+                    r4 = readPages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56584;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x56584;
+                    pc=0x39200;
+                    run_39200(); return;
+                case 0x56584:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    writePages[(r22+0)>>>12][((r22+0)>>>2)&0x3ff] = r16;
+                    r2 = r21 + r0;
+                    r23 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r22 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r21 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r28+-30616)>>>12][((r28+-30616)>>>2)&0x3ff] = r0;
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x565c0:
+                    r21 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5648c;
+                    continue;
+                case 0x565cc:
+                    r16 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x56454;
+                    continue;
+                case 0x56600:
+                    pc=0x56600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_56600() throws ExecutionException { /* 0x56600 - 0x56800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x56600:
+                    r29 = r29 + -96;
+                    r6 = r29 + 16;
+                    r7 = r29 + 80;
+                    r2 = r0 + 32;
+                    r5 = r5 & 65535;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r31;
+                    addr=r29+80;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x56624;
+                    pc=0x56400;
+                    run_56400(); return;
+                case 0x56624:
+                    addr=r29+80;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r5 = tmp;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x56638;
+                    pc=0x498e4;
+                    run_49800(); return;
+                case 0x56638:
+                    r31 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r29 = r29 + 96;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x56800:
+                    pc=0x56800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_56800() throws ExecutionException { /* 0x56800 - 0x56a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x56800:
+                    r4 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5a200;
+                    run_5a200(); return;
+                case 0x56a00:
+                    pc=0x56a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_56a00() throws ExecutionException { /* 0x56a00 - 0x56c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x56a00:
+                    r29 = r29 + -48;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r28+-31076)>>>12][((r28+-31076)>>>2)&0x3ff];
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r17;
+                    r2 = readPages[(r16+328)>>>12][((r16+328)>>>2)&0x3ff];
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56b30;
+                        continue;
+                    }
+                case 0x56a24:
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r8 = r3 < 32 ? 1 : 0;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56aac;
+                        continue;
+                    }
+                    r2 = 4 << 16;
+                    r2 = r2 + -6144;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56a64;
+                        continue;
+                    }
+                case 0x56a48:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r17 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r16 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x56a64:
+                    r4 = r0 + 400;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r6;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x56a7c;
+                    pc=0x3e800;
+                    run_3e800(); return;
+                case 0x56a7c:
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r6 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r7 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56a48;
+                        continue;
+                    }
+                    r3 = readPages[(r16+328)>>>12][((r16+328)>>>2)&0x3ff];
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    writePages[(r16+328)>>>12][((r16+328)>>>2)&0x3ff] = r2;
+                    r3 = r0 + r0;
+                    writePages[(r2+392)>>>12][((r2+392)>>>2)&0x3ff] = r0;
+                    writePages[(r2+396)>>>12][((r2+396)>>>2)&0x3ff] = r0;
+                case 0x56aac:
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56ae8;
+                        continue;
+                    }
+                case 0x56ab4:
+                    r4 = r3 + 1;
+                    r3 = r3 + 2;
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r3 = r3 << 2;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r4;
+                    r2 = r2 + r3;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r5;
+                    r17 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r16 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x56ae8:
+                    r4 = r3 << 2;
+                    r4 = r2 + r4;
+                    writePages[(r4+136)>>>12][((r4+136)>>>2)&0x3ff] = r6;
+                    r8 = readPages[(r2+392)>>>12][((r2+392)>>>2)&0x3ff];
+                    r6 = r0 + 1;
+                    r6 = r6 << (r3&0x1f);
+                    r8 = r8 | r6;
+                    writePages[(r2+392)>>>12][((r2+392)>>>2)&0x3ff] = r8;
+                    writePages[(r4+264)>>>12][((r4+264)>>>2)&0x3ff] = r7;
+                    r4 = r0 + 2;
+                    if(r17 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56ab4;
+                        continue;
+                    }
+                    r4 = readPages[(r2+396)>>>12][((r2+396)>>>2)&0x3ff];
+                    r6 = r4 | r6;
+                    writePages[(r2+396)>>>12][((r2+396)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x56ab4;
+                    continue;
+                case 0x56b30:
+                    r2 = r16 + 332;
+                    writePages[(r16+328)>>>12][((r16+328)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x56a24;
+                    continue;
+                case 0x56c00:
+                    pc=0x56c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_56c00() throws ExecutionException { /* 0x56c00 - 0x56e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x56c00:
+                    r2 = readPages[(r28+-31076)>>>12][((r28+-31076)>>>2)&0x3ff];
+                    r29 = r29 + -64;
+                    r2 = r2 + 328;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r21;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r30;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r23;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r22;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r4;
+                    r19 = r5 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r20 = r0 + 1;
+                    r21 = r0 + -1;
+                case 0x56c48:
+                    r2 = readPages[(r28+-31076)>>>12][((r28+-31076)>>>2)&0x3ff];
+                    r23 = readPages[(r2+328)>>>12][((r2+328)>>>2)&0x3ff];
+                    if(r23 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56ccc;
+                        continue;
+                    }
+                    r30 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x56c64:
+                    r3 = readPages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff];
+                    r16 = r3 + -1;
+                    if(r16 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56cbc;
+                        continue;
+                    }
+                    r18 = r3 + 1;
+                    r17 = r23 + 136;
+                    r4 = r16 << 2;
+                    r18 = r18 << 2;
+                    r17 = r17 + r4;
+                    r18 = r23 + r18;
+                case 0x56c90:
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56d00;
+                        continue;
+                    }
+                    r3 = readPages[(r17+128)>>>12][((r17+128)>>>2)&0x3ff];
+                    if(r3 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56d00;
+                        continue;
+                    }
+                case 0x56ca8:
+                    r16 = r16 + -1;
+                    r17 = r17 + -4;
+                    r18 = r18 + -4;
+                    if(r16 != r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56c90;
+                        continue;
+                    }
+                case 0x56cbc:
+                    r2 = 4 << 16;
+                    r2 = r2 + -5632;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56db4;
+                        continue;
+                    }
+                case 0x56ccc:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x56d00:
+                    r4 = readPages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff];
+                    r3 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    r4 = r4 + -1;
+                    if(r4 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56d94;
+                        continue;
+                    }
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r0;
+                case 0x56d18:
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56ca8;
+                        continue;
+                    }
+                    r5 = readPages[(r23+392)>>>12][((r23+392)>>>2)&0x3ff];
+                    r4 = r20 << (r16&0x1f);
+                    r5 = r4 & r5;
+                    r22 = readPages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56d84;
+                        continue;
+                    }
+                    r5 = readPages[(r23+396)>>>12][((r23+396)>>>2)&0x3ff];
+                    r4 = r4 & r5;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56da0;
+                        continue;
+                    }
+                    r4 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r5 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    r31=0x56d5c;
+                    return;
+                case 0x56d5c:
+                    r3 = readPages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff];
+                    if(r3 != r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56c48;
+                        continue;
+                    }
+                    r3 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    if(r3 == r23) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56ca8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x56c48;
+                    continue;
+                case 0x56d84:
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    r31=0x56d8c;
+                    return;
+                case 0x56d8c:
+                    /* Next insn is delay slot */ 
+                    pc=0x56d5c;
+                    continue;
+                case 0x56d94:
+                    writePages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x56d18;
+                    continue;
+                case 0x56da0:
+                    r4 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    r31=0x56dac;
+                    return;
+                case 0x56dac:
+                    /* Next insn is delay slot */ 
+                    pc=0x56d5c;
+                    continue;
+                case 0x56db4:
+                    r3 = readPages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56dfc;
+                        continue;
+                    }
+                    r3 = readPages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56e10;
+                        run_56e00(); return;
+                    }
+                    r4 = r23 + r0;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x56de4;
+                    pc=0x3ea00;
+                    run_3ea00(); return;
+                case 0x56de4:
+                    r23 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                case 0x56dec:
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x56c64;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x56ccc;
+                    continue;
+                case 0x56dfc:
+                    r3 = readPages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff];
+                case 0x56e00:
+                    pc=0x56e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_56e00() throws ExecutionException { /* 0x56e00 - 0x57000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x56e00:
+                    r30 = r23 + r0;
+                    r23 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x56dec;
+                    run_56c00(); return;
+                case 0x56e10:
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x56e00;
+                    continue;
+                case 0x57000:
+                    pc=0x57000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_57000() throws ExecutionException { /* 0x57000 - 0x57200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x57000:
+                    r29 = r29 + -48;
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r17 = readPages[(r5+16)>>>12][((r5+16)>>>2)&0x3ff];
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    r2 = r2 < r17 ? 1 : 0;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r20 = r4 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57274;
+                        run_57200(); return;
+                    }
+                    r17 = r17 + -1;
+                    r12 = r17 << 2;
+                    r16 = r5 + 20;
+                    r18 = r16 + r12;
+                    r19 = r4 + 20;
+                    r12 = r19 + r12;
+                    r22 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    r2 = readPages[(r12+0)>>>12][((r12+0)>>>2)&0x3ff];
+                    r22 = r22 + 1;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r22!=0) {
+                        hi = (int)((r2 & 0xffffffffL) % (r22 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r22 & 0xffffffffL));
+                        }
+                        pc=0x5706c;
+                        continue;
+                    }
+                    if(r22!=0) {
+                    hi = (int)((r2 & 0xffffffffL) % (r22 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r22 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x5706c:
+                    r22 = lo;
+                    r21 = lo;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57168;
+                        continue;
+                    }
+                    r6 = r16 + r0;
+                    r3 = r19 + r0;
+                    r4 = r0 + r0;
+                    r2 = r0 + r0;
+                case 0x5708c:
+                    r6 = r6 + 4;
+                    r11 = readPages[(r6+-4)>>>12][((r6+-4)>>>2)&0x3ff];
+                    r8 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r10 = r11 & 65535;
+                    { long hilo = (long)(r22) * ((long)r10); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r11 = r11 >>> 16;
+                    r3 = r3 + 4;
+                    r10 = lo;
+                    r10 = r4 + r10;
+                    r4 = r10 >>> 16;
+                    { long hilo = (long)(r22) * ((long)r11); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r7 = r10 & 65535;
+                    r7 = r2 - r7;
+                    r11 = lo;
+                    r9 = r4 + r11;
+                    r11 = r8 & 65535;
+                    r7 = r7 + r11;
+                    r4 = r9 >>> 16;
+                    r8 = r8 >>> 16;
+                    r9 = r9 & 65535;
+                    r2 = r7 >> 16;
+                    r8 = r8 - r9;
+                    r8 = r8 + r2;
+                    r2 = r8 >> 16;
+                    r7 = r7 & 65535;
+                    r8 = r8 << 16;
+                    r7 = r8 | r7;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r7;
+                    r7 = ((r18 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5708c;
+                        continue;
+                    }
+                    r2 = readPages[(r12+0)>>>12][((r12+0)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57168;
+                        continue;
+                    }
+                    r2 = r12 + -4;
+                    r3 = ((r19 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57164;
+                        continue;
+                    }
+                    r3 = readPages[(r12+-4)>>>12][((r12+-4)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57150;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x57164;
+                    continue;
+                case 0x57140:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57164;
+                        continue;
+                    }
+                case 0x57150:
+                    r2 = r2 + -4;
+                    r3 = ((r19 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    r17 = r17 + -1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57140;
+                        continue;
+                    }
+                case 0x57164:
+                    writePages[(r20+16)>>>12][((r20+16)>>>2)&0x3ff] = r17;
+                case 0x57168:
+                    r4 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x57174;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x57174:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57244;
+                        run_57200(); return;
+                    }
+                    r21 = r22 + 1;
+                    r3 = r19 + r0;
+                    r8 = r0 + r0;
+                case 0x57188:
+                    r16 = r16 + 4;
+                    r7 = readPages[(r16+-4)>>>12][((r16+-4)>>>2)&0x3ff];
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r5 = r7 & 65535;
+                    r2 = r6 & 65535;
+                    r5 = r8 - r5;
+                    r5 = r5 + r2;
+                    r6 = r6 >>> 16;
+                    r7 = r7 >>> 16;
+                    r2 = r5 >> 16;
+                    r6 = r6 - r7;
+                    r6 = r6 + r2;
+                    r8 = r6 >> 16;
+                    r5 = r5 & 65535;
+                    r6 = r6 << 16;
+                    r5 = r6 | r5;
+                    r3 = r3 + 4;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r5;
+                    r5 = ((r18 & 0xffffffffL) < (r16 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57188;
+                        continue;
+                    }
+                    r3 = r17 << 2;
+                    r3 = r19 + r3;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57244;
+                        run_57200(); return;
+                    }
+                    r2 = r3 + -4;
+                    r4 = ((r19 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57240;
+                        run_57200(); return;
+                    }
+                case 0x57200:
+                    pc=0x57200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_57200() throws ExecutionException { /* 0x57200 - 0x57400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x57200:
+                    r3 = readPages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5722c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x57240;
+                    continue;
+                case 0x5721c:
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57240;
+                        continue;
+                    }
+                case 0x5722c:
+                    r2 = r2 + -4;
+                    r3 = ((r19 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    r17 = r17 + -1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5721c;
+                        continue;
+                    }
+                case 0x57240:
+                    writePages[(r20+16)>>>12][((r20+16)>>>2)&0x3ff] = r17;
+                case 0x57244:
+                    r2 = r21 + r0;
+                case 0x57248:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x57274:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57248;
+                    continue;
+                case 0x57400:
+                    pc=0x57400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_57400() throws ExecutionException { /* 0x57400 - 0x57600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x57400:
+                    r5 = readPages[(r4+64)>>>12][((r4+64)>>>2)&0x3ff];
+                    r29 = r29 + -128;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r17;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r16;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r31;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r30;
+                    writePages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff] = r23;
+                    writePages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff] = r22;
+                    writePages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff] = r21;
+                    writePages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff] = r20;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r19;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r18;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = f20;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = f21;
+                    r16 = r4 + r0;
+                    r17 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r7;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r6;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57470;
+                        continue;
+                    }
+                    r2 = readPages[(r4+68)>>>12][((r4+68)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    writePages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff] = r2;
+                    r2 = r3 << (r2&0x1f);
+                    writePages[(r5+8)>>>12][((r5+8)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x5746c;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x5746c:
+                    writePages[(r16+64)>>>12][((r16+64)>>>2)&0x3ff] = r0;
+                case 0x57470:
+                    r2 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5757c;
+                        continue;
+                    }
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r0;
+                case 0x57488:
+                    r2 = 32752 << 16;
+                    r3 = r18 & r2;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57524;
+                        continue;
+                    }
+                    f20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f0 = r0;
+                    f21 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    f1 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x575a0;
+                        continue;
+                    }
+                    r9 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r3 = readPages[(r29+160)>>>12][((r29+160)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    writePages[(r9+0)>>>12][((r9+0)>>>2)&0x3ff] = r2;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57b6c;
+                        run_57a00(); return;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + 277;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = 7 << 16;
+                    r2 = r2 + 276;
+                case 0x574e8:
+                    f20 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r31 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r30 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    r23 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    r22 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r21 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    r20 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r19 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r18 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r17 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r16 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    f21 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r29 = r29 + 128;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x57524:
+                    r8 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r9 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r0 + 9999;
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r2;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57b0c;
+                        run_57a00(); return;
+                    }
+                case 0x5753c:
+                    r2 = 7 << 16;
+                    r2 = r2 + 2072;
+                case 0x57544:
+                    r3 = readPages[(r29+160)>>>12][((r29+160)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x574e8;
+                        continue;
+                    }
+                    addr=r2+3;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57b30;
+                        run_57a00(); return;
+                    }
+                    r3 = r2 + 3;
+                case 0x57568:
+                    r8 = readPages[(r29+160)>>>12][((r29+160)>>>2)&0x3ff];
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x574e8;
+                    continue;
+                case 0x5757c:
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = 32767 << 16;
+                    r18 = r18 | 65535;
+                    r2 = r0 + 1;
+                    r18 = r18 & r3;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x57488;
+                    continue;
+                case 0x575a0:
+                    r2 = r29 + 24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r7 = f20;
+                    r2 = r29 + 28;
+                    r6 = f21;
+                    r4 = r16 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x575c4;
+                    pc=0x5d600;
+                    run_5d600(); return;
+                case 0x575c4:
+                    r4 = r18 >>> 20;
+                    r17 = r2 + r0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57b3c;
+                        run_57a00(); return;
+                    }
+                    r5 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = r5 + r4;
+                    r2 = r4 < -1041 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x581f0;
+                        run_58000(); return;
+                    }
+                    r2 = r0 + -1010;
+                    r2 = r2 - r4;
+                    r6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = r18 << (r2&0x1f);
+                case 0x57600:
+                    pc=0x57600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_57600() throws ExecutionException { /* 0x57600 - 0x57800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x57600:
+                    r2 = r4 + 1042;
+                    r2 = r6 >>> (r2&0x1f);
+                    r18 = r18 | r2;
+                case 0x5760c:
+                    f0 = r18;
+                    { long l = Double.doubleToLongBits(((double)f0)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    if(r18 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58798;
+                        run_58600(); return;
+                    }
+                case 0x57620:
+                    r2 = f3;
+                    r6 = 65040 << 16;
+                    r3 = f2;
+                    r2 = r6 + r2;
+                    r4 = r4 + -1;
+                    r19 = r0 + 1;
+                case 0x57638:
+                    f4 = r3;
+                    f0 = readPages[(r28+-31044)>>>12][((r28+-31044)>>>2)&0x3ff];
+                    f5 = r2;
+                    f1 = readPages[(r28+-31048)>>>12][((r28+-31048)>>>2)&0x3ff];
+                    f6 = r4;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f0 = readPages[(r28+-31036)>>>12][((r28+-31036)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31040)>>>12][((r28+-31040)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f0 = readPages[(r28+-31028)>>>12][((r28+-31028)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31032)>>>12][((r28+-31032)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f0 = readPages[(r28+-31020)>>>12][((r28+-31020)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits(((double)f6)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f1 = readPages[(r28+-31024)>>>12][((r28+-31024)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r2 = fcsr;
+                    r2 = fcsr;
+                    r1 = r2 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r2;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = f0;
+                    f0 = r0;
+                    f1 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58184;
+                        run_58000(); return;
+                    }
+                case 0x576dc:
+                    r8 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = (r8&0xffffffffL) < (23&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5814c;
+                        run_58000(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r8 << 3;
+                    r3 = r3 + 2176;
+                    r2 = r2 + r3;
+                    f0 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f2 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f1 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    f3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58208;
+                        run_58200(); return;
+                    }
+                    r8 = r8 + -1;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r8;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                case 0x57730:
+                    r4 = r5 - r4;
+                    r23 = r4 + -1;
+                    if(r23 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58174;
+                        run_58000(); return;
+                    }
+                    r18 = r0 + r0;
+                case 0x57744:
+                    r8 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    if(r8 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5815c;
+                        run_58000(); return;
+                    }
+                    r23 = r23 + r8;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r8;
+                    r22 = r0 + r0;
+                case 0x57760:
+                    r3 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r2 = (r3&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57b7c;
+                        run_57a00(); return;
+                    }
+                    r2 = r3 < 6 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58bf8;
+                        run_58a00(); return;
+                    }
+                    r3 = r3 + -4;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r3;
+                    r8 = r0 + r0;
+                case 0x5778c:
+                    r9 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    if(r9 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x587b4;
+                        run_58600(); return;
+                    }
+                    r2 = r9 < 4 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5862c;
+                        run_58600(); return;
+                    }
+                    r3 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r2 = r0 + 4;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x583fc;
+                        run_58200(); return;
+                    }
+                    r2 = r0 + 5;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57b80;
+                        run_57a00(); return;
+                    }
+                    r3 = r0 + 1;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r3;
+                case 0x577cc:
+                    r9 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r3 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r9 = r9 + r3;
+                    r30 = r9 + 1;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r9;
+                    if(r30 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58818;
+                        run_58800(); return;
+                    }
+                    r6 = r30 + r0;
+                case 0x577f0:
+                    r2 = (r6&0xffffffffL) < (24&0xffffffffL) ? 1 : 0;
+                    writePages[(r16+68)>>>12][((r16+68)>>>2)&0x3ff] = r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58c04;
+                        run_58c00(); return;
+                    }
+                case 0x57800:
+                    pc=0x57800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_57800() throws ExecutionException { /* 0x57800 - 0x57a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x57800:
+                    r3 = r0 + 1;
+                    r2 = r0 + 4;
+                case 0x57808:
+                    r2 = r2 << 1;
+                    r4 = r2 + 20;
+                    r4 = ((r6 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    r5 = r3 + r0;
+                    r3 = r3 + 1;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57808;
+                        continue;
+                    }
+                    writePages[(r16+68)>>>12][((r16+68)>>>2)&0x3ff] = r5;
+                    r21 = r6 + r0;
+                case 0x5782c:
+                    r4 = r16 + r0;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r8;
+                    r21 = (r21&0xffffffffL) < (15&0xffffffffL) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    r31=0x57840;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x57840:
+                    r20 = r2 + r0;
+                    writePages[(r16+64)>>>12][((r16+64)>>>2)&0x3ff] = r2;
+                    r8 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57bb4;
+                        run_57a00(); return;
+                    }
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57bb4;
+                        run_57a00(); return;
+                    }
+                    f8 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r8 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f9 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    if(r8 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5882c;
+                        run_58800(); return;
+                    }
+                    r3 = r8 & 15;
+                    r2 = 7 << 16;
+                    r3 = r3 << 3;
+                    r2 = r2 + 2176;
+                    r2 = r3 + r2;
+                    f2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r2 = r8 >> 4;
+                    r3 = r2 & 16;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x587e0;
+                        run_58600(); return;
+                    }
+                    r3 = 7 << 16;
+                    f0 = readPages[(r3+2172)>>>12][((r3+2172)>>>2)&0x3ff];
+                    r2 = r2 & 15;
+                    f1 = readPages[(r3+2168)>>>12][((r3+2168)>>>2)&0x3ff];
+                    r8 = r0 + 3;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x578b8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x578f8;
+                        continue;
+                    }
+                    r3 = 7 << 16;
+                    r3 = r3 + 2136;
+                case 0x578c8:
+                    r4 = r2 & 1;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x578e8;
+                        continue;
+                    }
+                    f4 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r8 = r8 + 1;
+                    f5 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                case 0x578e8:
+                    r2 = r2 >> 1;
+                    r3 = r3 + 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x578c8;
+                        continue;
+                    }
+                case 0x578f8:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x578fc:
+                    r3 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5792c;
+                        continue;
+                    }
+                    f2 = readPages[(r28+-31012)>>>12][((r28+-31012)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31016)>>>12][((r28+-31016)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58ab4;
+                        run_58a00(); return;
+                    }
+                case 0x5792c:
+                    f4 = r8;
+                    r2 = 64704 << 16;
+                    { long l = Double.doubleToLongBits(((double)f4)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = readPages[(r28+-30996)>>>12][((r28+-30996)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31000)>>>12][((r28+-31000)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    r8 = f7;
+                    r9 = f6;
+                    r8 = r2 + r8;
+                    if(r30 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58700;
+                        run_58600(); return;
+                    }
+                    r2 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r4 = r30 + r0;
+                case 0x5796c:
+                    r3 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r5 = r4 + -1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58974;
+                        run_58800(); return;
+                    }
+                    r3 = 7 << 16;
+                    r5 = r5 << 3;
+                    r3 = r3 + 2176;
+                    r3 = r5 + r3;
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-30980)>>>12][((r28+-30980)>>>2)&0x3ff];
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-30984)>>>12][((r28+-30984)>>>2)&0x3ff];
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f6 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f6 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f6 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f6 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))/(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f4 = r9;
+                    r7 = f6;
+                    f5 = r8;
+                    r5 = r7 + 48;
+                    r5 = r5 << 24;
+                    r5 = r5 >> 24;
+                    r3 = r20 + 1;
+                    addr=r20+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits(((double)f6)); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57ac0;
+                        run_57a00(); return;
+                    }
+                case 0x57a00:
+                    pc=0x57a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_57a00() throws ExecutionException { /* 0x57a00 - 0x57c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x57a00:
+                    f10 = readPages[(r28+-31012)>>>12][((r28+-31012)>>>2)&0x3ff];
+                    f11 = readPages[(r28+-31016)>>>12][((r28+-31016)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58b80;
+                        run_58a00(); return;
+                    }
+                    r5 = r4 < 2 ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58768;
+                        run_58600(); return;
+                    }
+                    f6 = readPages[(r28+-31004)>>>12][((r28+-31004)>>>2)&0x3ff];
+                    r4 = r20 + r4;
+                    f7 = readPages[(r28+-31008)>>>12][((r28+-31008)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x57a64;
+                    continue;
+                case 0x57a48:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58b80;
+                        run_58a00(); return;
+                    }
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58768;
+                        run_58600(); return;
+                    }
+                case 0x57a64:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = r3 + 1;
+                    r8 = fcsr;
+                    r8 = fcsr;
+                    r1 = r8 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f12 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f12 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f12 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f12 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r8;
+                    { long l = Double.doubleToLongBits(((double)f12)); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r9 = f12;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = r9 + 48;
+                    r5 = r5 << 24;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    r5 = r5 >> 24;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57a48;
+                        continue;
+                    }
+                case 0x57ac0:
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r2;
+                case 0x57ac4:
+                    r4 = r16 + r0;
+                    r5 = r17 + r0;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x57ad8;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x57ad8:
+                    r8 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r2 = r8 + 1;
+                    r9 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r8 = readPages[(r29+160)>>>12][((r29+160)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r9+0)>>>12][((r9+0)>>>2)&0x3ff] = r2;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58620;
+                        run_58600(); return;
+                    }
+                    writePages[(r8+0)>>>12][((r8+0)>>>2)&0x3ff] = r3;
+                    r2 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x574e8;
+                    run_57400(); return;
+                case 0x57b0c:
+                    r2 = 15 << 16;
+                    r2 = r2 | 65535;
+                    r18 = r18 & r2;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5753c;
+                        run_57400(); return;
+                    }
+                    r2 = 7 << 16;
+                    r2 = r2 + 2060;
+                    /* Next insn is delay slot */ 
+                    pc=0x57544;
+                    run_57400(); return;
+                case 0x57b30:
+                    r3 = r2 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x57568;
+                    run_57400(); return;
+                case 0x57b3c:
+                    r2 = f21;
+                    r6 = 15 << 16;
+                    r6 = r6 | 65535;
+                    r5 = 16368 << 16;
+                    r6 = r2 & r6;
+                    r2 = r6 | r5;
+                    r3 = f20;
+                    r4 = r4 + -1023;
+                    r5 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r19 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57638;
+                    run_57600(); return;
+                case 0x57b6c:
+                    r2 = 7 << 16;
+                    r2 = r2 + 276;
+                    /* Next insn is delay slot */ 
+                    pc=0x574e8;
+                    run_57400(); return;
+                case 0x57b7c:
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r0;
+                case 0x57b80:
+                    writePages[(r16+68)>>>12][((r16+68)>>>2)&0x3ff] = r0;
+                    r4 = r16 + r0;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x57b94;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x57b94:
+                    r8 = r0 + -1;
+                    r9 = r0 + 1;
+                    r20 = r2 + r0;
+                    writePages[(r16+64)>>>12][((r16+64)>>>2)&0x3ff] = r2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r0;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r8;
+                    r30 = r0 + -1;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r9;
+                case 0x57bb4:
+                    r2 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57d7c;
+                        run_57c00(); return;
+                    }
+                    r8 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r3 = r8 < 15 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57d7c;
+                        run_57c00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r8 << 3;
+                    r3 = r3 + 2176;
+                    r2 = r2 + r3;
+                    f2 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r9 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    f3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r9 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58428;
+                        run_58400(); return;
+                    }
+                case 0x57bfc:
+                    f6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                case 0x57c00:
+                    pc=0x57c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_57c00() throws ExecutionException { /* 0x57c00 - 0x57e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x57c00:
+                    f7 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))/(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r2 = fcsr;
+                    r2 = fcsr;
+                    r1 = r2 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f10 = (int)Math.floor((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f10 = (int)(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL))); break; // Round towards zero
+                        case 2: f10 = (int)Math.ceil((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f10 = (int)Math.floor((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r2;
+                    { long l = Double.doubleToLongBits(((double)f10)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r4 = f10;
+                    r3 = r20 + 1;
+                    r2 = r4 + 48;
+                    addr=r20+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r30 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57d00;
+                        continue;
+                    }
+                    f6 = readPages[(r28+-31004)>>>12][((r28+-31004)>>>2)&0x3ff];
+                    f8 = r0;
+                    f7 = readPages[(r28+-31008)>>>12][((r28+-31008)>>>2)&0x3ff];
+                    f9 = r0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))==(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57ac4;
+                        run_57a00(); return;
+                    }
+                    r2 = r20 + 2;
+                    r30 = r20 + r30;
+                    /* Next insn is delay slot */ 
+                    pc=0x57cac;
+                    continue;
+                case 0x57c94:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r2 = r2 + 1;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))==(Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57ac4;
+                        run_57a00(); return;
+                    }
+                case 0x57cac:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))/(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r3 = r2 + r0;
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f10 = (int)Math.floor((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f10 = (int)(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL))); break; // Round towards zero
+                        case 2: f10 = (int)Math.ceil((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f10 = (int)Math.floor((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    { long l = Double.doubleToLongBits(((double)f10)); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    r5 = f10;
+                    r4 = r5 + 48;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r2 != r30) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57c94;
+                        continue;
+                    }
+                case 0x57d00:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57d38;
+                        continue;
+                    }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57ac4;
+                        run_57a00(); return;
+                    }
+                    r4 = f10;
+                    r2 = r4 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57ac4;
+                        run_57a00(); return;
+                    }
+                case 0x57d38:
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                case 0x57d3c:
+                    r4 = r0 + 57;
+                    /* Next insn is delay slot */ 
+                    pc=0x57d58;
+                    continue;
+                case 0x57d48:
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x588b4;
+                        run_58800(); return;
+                    }
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r3 = r2 + r0;
+                case 0x57d58:
+                    r2 = r3 + -1;
+                    if(r5 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57d48;
+                        continue;
+                    }
+                    r4 = r5 + 1;
+                    r4 = r4 << 24;
+                    r4 = r4 >> 24;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x57ac4;
+                    run_57a00(); return;
+                case 0x57d7c:
+                    r8 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x581b8;
+                        run_58000(); return;
+                    }
+                    r9 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r9 = r9 < 2 ? 1 : 0;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r9;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x584fc;
+                        run_58400(); return;
+                    }
+                    r3 = r30 + -1;
+                    r2 = r22 < r3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x587c0;
+                        run_58600(); return;
+                    }
+                    r3 = r22 - r3;
+                case 0x57db8:
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58a78;
+                        run_58a00(); return;
+                    }
+                    r21 = r18 + r0;
+                    r2 = r30 + r0;
+                case 0x57dc8:
+                    r4 = r16 + r0;
+                    r5 = r0 + 1;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    r18 = r18 + r2;
+                    r23 = r23 + r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x57de4;
+                    pc=0x5c400;
+                    run_5c400(); return;
+                case 0x57de4:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r19 = r2 + r0;
+                case 0x57dec:
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57e18;
+                        run_57e00(); return;
+                    }
+                    if(r23 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57e18;
+                        run_57e00(); return;
+                    }
+                    r4 = r21 < r23 ? 1 : 0;
+                case 0x57e00:
+                    pc=0x57e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_57e00() throws ExecutionException { /* 0x57e00 - 0x58000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x57e00:
+                    r2 = r23 + r0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x583f0;
+                        run_58200(); return;
+                    }
+                case 0x57e0c:
+                    r18 = r18 - r2;
+                    r21 = r21 - r2;
+                    r23 = r23 - r2;
+                case 0x57e18:
+                    if(r22 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57e94;
+                        continue;
+                    }
+                    r9 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58778;
+                        run_58600(); return;
+                    }
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57e88;
+                        continue;
+                    }
+                    r6 = r3 + r0;
+                    r5 = r19 + r0;
+                    r4 = r16 + r0;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x57e50;
+                    pc=0x5ca00;
+                    run_5ca00(); return;
+                case 0x57e50:
+                    r5 = r2 + r0;
+                    r6 = r17 + r0;
+                    r4 = r16 + r0;
+                    r19 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x57e68;
+                    pc=0x5c600;
+                    run_5c600(); return;
+                case 0x57e68:
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x57e7c;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x57e7c:
+                    r2 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r17 = r2 + r0;
+                case 0x57e88:
+                    r6 = r22 - r3;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x584a4;
+                        run_58400(); return;
+                    }
+                case 0x57e94:
+                    r4 = r16 + r0;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x57ea4;
+                    pc=0x5c400;
+                    run_5c400(); return;
+                case 0x57ea4:
+                    r3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r22 = r2 + r0;
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57ecc;
+                        continue;
+                    }
+                    r4 = r16 + r0;
+                    r5 = r2 + r0;
+                    r6 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x57ec8;
+                    pc=0x5ca00;
+                    run_5ca00(); return;
+                case 0x57ec8:
+                    r22 = r2 + r0;
+                case 0x57ecc:
+                    r7 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x583a0;
+                        run_58200(); return;
+                    }
+                case 0x57edc:
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r0;
+                case 0x57ee0:
+                    r7 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x585f0;
+                        run_58400(); return;
+                    }
+                    r2 = r0 + 1;
+                case 0x57ef4:
+                    r2 = r2 + r23;
+                    r2 = r2 & 31;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x581d8;
+                        run_58000(); return;
+                    }
+                    r3 = r0 + 32;
+                    r3 = r3 - r2;
+                    r4 = r3 < 5 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58bdc;
+                        run_58a00(); return;
+                    }
+                    r3 = r0 + 28;
+                    r2 = r3 - r2;
+                    r18 = r18 + r2;
+                    r21 = r21 + r2;
+                    r23 = r23 + r2;
+                case 0x57f2c:
+                    if(r18 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57f4c;
+                        continue;
+                    }
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    r6 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x57f48;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x57f48:
+                    r17 = r2 + r0;
+                case 0x57f4c:
+                    if(r23 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57f6c;
+                        continue;
+                    }
+                    r5 = r22 + r0;
+                    r4 = r16 + r0;
+                    r6 = r23 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x57f68;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x57f68:
+                    r22 = r2 + r0;
+                case 0x57f6c:
+                    r8 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58348;
+                        run_58200(); return;
+                    }
+                case 0x57f7c:
+                    if(r30 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58644;
+                        run_58600(); return;
+                    }
+                case 0x57f84:
+                    r9 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58214;
+                        run_58200(); return;
+                    }
+                    if(r21 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57fb4;
+                        continue;
+                    }
+                    r5 = r19 + r0;
+                    r4 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x57fb0;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x57fb0:
+                    r19 = r2 + r0;
+                case 0x57fb4:
+                    r3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x588d8;
+                        run_58800(); return;
+                    }
+                    r21 = r19 + r0;
+                case 0x57fc8:
+                    r8 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r30 = r20 + r30;
+                    r8 = r8 & 1;
+                    r18 = r20 + 1;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r8;
+                case 0x57fe0:
+                    r9 = r18 + -1;
+                    r4 = r17 + r0;
+                    r5 = r22 + r0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r9;
+                    /* Next insn is delay slot */ 
+                    r31=0x57ff8;
+                    pc=0x57000;
+                    run_57000(); return;
+                case 0x57ff8:
+                    r4 = r17 + r0;
+                    r5 = r19 + r0;
+                case 0x58000:
+                    pc=0x58000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_58000() throws ExecutionException { /* 0x58000 - 0x58200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x58000:
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r23 = r2 + 48;
+                    /* Next insn is delay slot */ 
+                    r31=0x58010;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x58010:
+                    r4 = r16 + r0;
+                    r5 = r22 + r0;
+                    r6 = r21 + r0;
+                    r30 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x58028;
+                    pc=0x5d000;
+                    run_5d000(); return;
+                case 0x58028:
+                    r3 = r2 + r0;
+                    r2 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x585d4;
+                        run_58400(); return;
+                    }
+                    r5 = r3 + r0;
+                    r4 = r17 + r0;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x58050;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x58050:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    r5 = r3 + r0;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x58068;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x58068:
+                    r2 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58098;
+                        continue;
+                    }
+                    r3 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58098;
+                        continue;
+                    }
+                    r8 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58590;
+                        run_58400(); return;
+                    }
+                case 0x58098:
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58524;
+                        run_58400(); return;
+                    }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x580c8;
+                        continue;
+                    }
+                    r8 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x580c8;
+                        continue;
+                    }
+                    r9 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58524;
+                        run_58400(); return;
+                    }
+                case 0x580c8:
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58928;
+                        run_58800(); return;
+                    }
+                    r8 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r3 = r18 + r0;
+                    addr=r18+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r23&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r18 == r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58954;
+                        run_58800(); return;
+                    }
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    r6 = r0 + 10;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x580fc;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x580fc:
+                    r17 = r2 + r0;
+                    r4 = r16 + r0;
+                    r5 = r19 + r0;
+                    r6 = r0 + 10;
+                    r7 = r0 + r0;
+                    if(r19 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x585b8;
+                        run_58400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x58120;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x58120:
+                    r5 = r21 + r0;
+                    r4 = r16 + r0;
+                    r6 = r0 + 10;
+                    r7 = r0 + r0;
+                    r19 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5813c;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x5813c:
+                    r21 = r2 + r0;
+                    r18 = r18 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x57fe0;
+                    run_57e00(); return;
+                case 0x5814c:
+                    r3 = r0 + 1;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x57730;
+                    run_57600(); return;
+                case 0x5815c:
+                    r9 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    r18 = r18 - r9;
+                    r22 = r0 - r9;
+                    /* Next insn is delay slot */ 
+                    pc=0x57760;
+                    run_57600(); return;
+                case 0x58174:
+                    r18 = r0 - r23;
+                    r23 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57744;
+                    run_57600(); return;
+                case 0x58184:
+                    f4 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits(((double)f4)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))==(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x576dc;
+                        run_57600(); return;
+                    }
+                    r3 = f4;
+                    r3 = r3 + -1;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x576dc;
+                    run_57600(); return;
+                case 0x581b8:
+                    r8 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r3 = r22 + r0;
+                    r8 = r8 < 2 ? 1 : 0;
+                    r21 = r18 + r0;
+                    r19 = r0 + r0;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    pc=0x57dec;
+                    run_57c00(); return;
+                case 0x581d8:
+                    r2 = r0 + 28;
+                case 0x581dc:
+                    r18 = r18 + r2;
+                    r21 = r21 + r2;
+                    r23 = r23 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x57f2c;
+                    run_57e00(); return;
+                case 0x581f0:
+                    r18 = r0 + -1042;
+                    r7 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = r18 - r4;
+                    r18 = r7 << (r18&0x1f);
+                case 0x58200:
+                    pc=0x58200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_58200() throws ExecutionException { /* 0x58200 - 0x58400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x58200:
+                    /* Next insn is delay slot */ 
+                    pc=0x5760c;
+                    run_57600(); return;
+                case 0x58208:
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57730;
+                    run_57600(); return;
+                case 0x58214:
+                    r18 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5823c;
+                    continue;
+                case 0x58220:
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    r6 = r0 + 10;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x58238;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x58238:
+                    r17 = r2 + r0;
+                case 0x5823c:
+                    r4 = r17 + r0;
+                    r5 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5824c;
+                    pc=0x57000;
+                    run_57000(); return;
+                case 0x5824c:
+                    r18 = r18 + 1;
+                    r23 = r2 + 48;
+                    r2 = r18 - r20;
+                    r2 = r2 < r30 ? 1 : 0;
+                    addr=r18+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r23&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58220;
+                        continue;
+                    }
+                    if(r30 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58518;
+                        run_58400(); return;
+                    }
+                case 0x58270:
+                    r3 = r20 + r30;
+                    r18 = r0 + r0;
+                case 0x58278:
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    r6 = r0 + 1;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x58290;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x58290:
+                    r4 = r2 + r0;
+                    r5 = r22 + r0;
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x582a4;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x582a4:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x584c0;
+                        run_58400(); return;
+                    }
+                case 0x582b0:
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                case 0x582b4:
+                    r5 = r0 + 57;
+                    /* Next insn is delay slot */ 
+                    pc=0x582d0;
+                    continue;
+                case 0x582c0:
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x586b4;
+                        run_58600(); return;
+                    }
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r2 + r0;
+                case 0x582d0:
+                    r2 = r3 + -1;
+                    if(r4 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x582c0;
+                        continue;
+                    }
+                    r4 = r4 + 1;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x582e4:
+                    r4 = r16 + r0;
+                    r5 = r22 + r0;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x582f8;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x582f8:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57ac4;
+                        run_57a00(); return;
+                    }
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58328;
+                        continue;
+                    }
+                    if(r18 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58328;
+                        continue;
+                    }
+                    r4 = r16 + r0;
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x58324;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x58324:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                case 0x58328:
+                    r4 = r16 + r0;
+                    r5 = r19 + r0;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x5833c;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x5833c:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x57ac4;
+                    run_57a00(); return;
+                case 0x58348:
+                    r4 = r17 + r0;
+                    r5 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x58358;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x58358:
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57f7c;
+                        run_57e00(); return;
+                    }
+                    r9 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r5 = r17 + r0;
+                    r9 = r9 + -1;
+                    r4 = r16 + r0;
+                    r6 = r0 + 10;
+                    r7 = r0 + r0;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r9;
+                    /* Next insn is delay slot */ 
+                    r31=0x58384;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x58384:
+                    r3 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r17 = r2 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58ba8;
+                        run_58a00(); return;
+                    }
+                    r30 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x57f7c;
+                    run_57e00(); return;
+                case 0x583a0:
+                    r8 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57edc;
+                        run_57e00(); return;
+                    }
+                    r2 = 15 << 16;
+                    r9 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r2 | 65535;
+                    r2 = r2 & r9;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57edc;
+                        run_57e00(); return;
+                    }
+                    r2 = 32752 << 16;
+                    r2 = r2 & r9;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57edc;
+                        run_57e00(); return;
+                    }
+                    r3 = r0 + 1;
+                    r18 = r18 + 1;
+                    r23 = r23 + 1;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x57ee0;
+                    run_57e00(); return;
+                case 0x583f0:
+                    r2 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57e0c;
+                    run_57e00(); return;
+                case 0x583fc:
+                    r9 = r0 + 1;
+                case 0x58400:
+                    pc=0x58400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_58400() throws ExecutionException { /* 0x58400 - 0x58600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x58400:
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r9;
+                case 0x58404:
+                    r4 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    if(r4 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x587f0;
+                        run_58600(); return;
+                    }
+                    r6 = r4 + r0;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r4;
+                    r30 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x577f0;
+                    run_57600(); return;
+                case 0x58428:
+                    if(r30 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57bfc;
+                        run_57a00(); return;
+                    }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58758;
+                        run_58600(); return;
+                    }
+                    f0 = readPages[(r28+-30988)>>>12][((r28+-30988)>>>2)&0x3ff];
+                    r22 = r0 + r0;
+                    f1 = readPages[(r28+-30992)>>>12][((r28+-30992)>>>2)&0x3ff];
+                    r19 = r0 + r0;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    f0 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f1 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<=(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58694;
+                        run_58600(); return;
+                    }
+                case 0x5846c:
+                    r9 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r3 = r20 + r0;
+                    r9 = ~(r0 | r9);
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r9;
+                case 0x5847c:
+                    r4 = r16 + r0;
+                    r5 = r22 + r0;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x58490;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x58490:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58328;
+                        run_58200(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x57ac4;
+                    run_57a00(); return;
+                case 0x584a4:
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x584b4;
+                    pc=0x5ca00;
+                    run_5ca00(); return;
+                case 0x584b4:
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57e94;
+                    run_57e00(); return;
+                case 0x584c0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x584d4;
+                        continue;
+                    }
+                    r23 = r23 & 1;
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x582b0;
+                        run_58200(); return;
+                    }
+                case 0x584d4:
+                    r5 = r0 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=0x584e4;
+                    continue;
+                case 0x584e0:
+                    r3 = r4 + r0;
+                case 0x584e4:
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r4 = r3 + -1;
+                    if(r2 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x584e0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x582e4;
+                    run_58200(); return;
+                case 0x584fc:
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58a88;
+                        run_58a00(); return;
+                    }
+                    r2 = r2 + 1075;
+                    r3 = r22 + r0;
+                    r21 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57dc8;
+                    run_57c00(); return;
+                case 0x58518:
+                    r30 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x58270;
+                    run_58200(); return;
+                case 0x58524:
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58574;
+                        continue;
+                    }
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    r6 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x58540;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x58540:
+                    r4 = r2 + r0;
+                    r5 = r22 + r0;
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x58554;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x58554:
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58b8c;
+                        run_58a00(); return;
+                    }
+                case 0x5855c:
+                    r2 = r0 + 57;
+                    if(r23 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58b1c;
+                        run_58a00(); return;
+                    }
+                    r3 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r23 = r3 + 49;
+                case 0x58574:
+                    r7 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = r19 + r0;
+                    r3 = r7 + 1;
+                    addr=r7+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r23&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x582e4;
+                    run_58200(); return;
+                case 0x58590:
+                    r2 = r0 + 57;
+                    if(r23 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58b1c;
+                        run_58a00(); return;
+                    }
+                    if(r30 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58574;
+                        continue;
+                    }
+                    r9 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r23 = r9 + 49;
+                    /* Next insn is delay slot */ 
+                    pc=0x58574;
+                    continue;
+                case 0x585b8:
+                    /* Next insn is delay slot */ 
+                    r31=0x585c0;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x585c0:
+                    r19 = r2 + r0;
+                    r21 = r2 + r0;
+                    r18 = r18 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x57fe0;
+                    run_57e00(); return;
+                case 0x585d4:
+                    r4 = r16 + r0;
+                    r5 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x585e4;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x585e4:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x58098;
+                    run_58000(); return;
+                case 0x585f0:
+                    r2 = readPages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff];
+                    r2 = r2 + 3;
+                    r2 = r2 << 2;
+                case 0x58600:
+                    pc=0x58600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_58600() throws ExecutionException { /* 0x58600 - 0x58800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x58600:
+                    r2 = r22 + r2;
+                    r4 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x58610;
+                    pc=0x5c000;
+                    run_5c000(); return;
+                case 0x58610:
+                    r3 = r0 + 32;
+                    r2 = r3 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x57ef4;
+                    run_57e00(); return;
+                case 0x58620:
+                    r2 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x574e8;
+                    run_57400(); return;
+                case 0x5862c:
+                    r2 = r0 + 2;
+                    if(r9 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57b80;
+                        run_57a00(); return;
+                    }
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x58404;
+                    run_58400(); return;
+                case 0x58644:
+                    r8 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r2 = r8 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57f84;
+                        run_57e00(); return;
+                    }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5846c;
+                        run_58400(); return;
+                    }
+                    r5 = r22 + r0;
+                    r4 = r16 + r0;
+                    r6 = r0 + 5;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x58678;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x58678:
+                    r5 = r2 + r0;
+                    r4 = r17 + r0;
+                    r22 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5868c;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x5868c:
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5846c;
+                        run_58400(); return;
+                    }
+                case 0x58694:
+                    r8 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r0 + 49;
+                    r8 = r8 + 1;
+                    r3 = r20 + 1;
+                    addr=r20+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    pc=0x5847c;
+                    run_58400(); return;
+                case 0x586b4:
+                    r9 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r0 + 49;
+                    r9 = r9 + 1;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r9;
+                    addr=r20+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x582e4;
+                    run_58200(); return;
+                case 0x586d0:
+                    f4 = r8;
+                    r2 = 64704 << 16;
+                    { long l = Double.doubleToLongBits(((double)f4)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = readPages[(r28+-30996)>>>12][((r28+-30996)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-31000)>>>12][((r28+-31000)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    r8 = f7;
+                    r9 = f6;
+                    r8 = r2 + r8;
+                case 0x58700:
+                    f2 = readPages[(r28+-30988)>>>12][((r28+-30988)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-30992)>>>12][((r28+-30992)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = r9;
+                    f3 = r8;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58964;
+                        run_58800(); return;
+                    }
+                    r4 = 32768 << 16;
+                    f2 = r9;
+                    r2 = r4 ^ r8;
+                    f3 = r2;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58768;
+                        continue;
+                    }
+                case 0x58758:
+                    r22 = r0 + r0;
+                    r19 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5846c;
+                    run_58400(); return;
+                case 0x58768:
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = f8;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = f9;
+                    /* Next insn is delay slot */ 
+                    pc=0x57bb4;
+                    run_57a00(); return;
+                case 0x58778:
+                    r5 = r17 + r0;
+                    r4 = r16 + r0;
+                    r6 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5878c;
+                    pc=0x5ca00;
+                    run_5ca00(); return;
+                case 0x5878c:
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57e94;
+                    run_57e00(); return;
+                case 0x58798:
+                    f0 = readPages[(r28+-31052)>>>12][((r28+-31052)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-31056)>>>12][((r28+-31056)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x57620;
+                    run_57600(); return;
+                case 0x587b4:
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x577cc;
+                    run_57600(); return;
+                case 0x587c0:
+                    r7 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r22 = r3 - r22;
+                    r7 = r7 + r22;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r7;
+                    r22 = r3 + r0;
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57db8;
+                    run_57c00(); return;
+                case 0x587e0:
+                    f0 = f8;
+                    f1 = f9;
+                    r8 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x578b8;
+                    run_57800(); return;
+                case 0x587f0:
+                    r3 = r0 + 1;
+                    r4 = r0 + 1;
+                    r21 = r0 + 1;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r3;
+                case 0x58800:
+                    pc=0x58800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_58800() throws ExecutionException { /* 0x58800 - 0x58a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x58800:
+                    r30 = r0 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r4;
+                    writePages[(r16+68)>>>12][((r16+68)>>>2)&0x3ff] = r0;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5782c;
+                    run_57800(); return;
+                case 0x58818:
+                    r21 = r30 + r0;
+                    writePages[(r16+68)>>>12][((r16+68)>>>2)&0x3ff] = r0;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5782c;
+                    run_57800(); return;
+                case 0x5882c:
+                    r9 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r0 - r9;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58aa4;
+                        run_58a00(); return;
+                    }
+                    r4 = r2 & 15;
+                    r3 = 7 << 16;
+                    r4 = r4 << 3;
+                    r3 = r3 + 2176;
+                    r3 = r4 + r3;
+                    f0 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r2 = r2 >> 4;
+                    f1 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f9&0xffffffffL) << 32) | (f8&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58bd0;
+                        run_58a00(); return;
+                    }
+                    r3 = 7 << 16;
+                    r3 = r3 + 2136;
+                    r8 = r0 + 2;
+                case 0x5887c:
+                    r4 = r2 & 1;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5889c;
+                        continue;
+                    }
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r8 = r8 + 1;
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x5889c:
+                    r2 = r2 >> 1;
+                    r3 = r3 + 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5887c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x578fc;
+                    run_57800(); return;
+                case 0x588b4:
+                    r8 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r4 = r0 + 48;
+                    addr=r20+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r8 = r8 + 1;
+                    r4 = r0 + 49;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r8;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x57ac4;
+                    run_57a00(); return;
+                case 0x588d8:
+                    r5 = readPages[(r19+4)>>>12][((r19+4)>>>2)&0x3ff];
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x588e8;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x588e8:
+                    r6 = readPages[(r19+16)>>>12][((r19+16)>>>2)&0x3ff];
+                    r18 = r2 + r0;
+                    r6 = r6 + 2;
+                    r4 = r2 + 12;
+                    r5 = r19 + 12;
+                    r6 = r6 << 2;
+                    /* Next insn is delay slot */ 
+                    r31=0x58908;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x58908:
+                    r4 = r16 + r0;
+                    r5 = r18 + r0;
+                    r6 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x5891c;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x5891c:
+                    r21 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57fc8;
+                    run_57e00(); return;
+                case 0x58928:
+                    r2 = r0 + 57;
+                    if(r23 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58b1c;
+                        run_58a00(); return;
+                    }
+                    r9 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r23 = r23 + 1;
+                    r18 = r19 + r0;
+                    r3 = r9 + 1;
+                    addr=r9+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r23&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x582e4;
+                    run_58200(); return;
+                case 0x58954:
+                    r18 = r19 + r0;
+                    r19 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x58278;
+                    run_58200(); return;
+                case 0x58964:
+                    r22 = r0 + r0;
+                    r19 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x58694;
+                    run_58600(); return;
+                case 0x58974:
+                    r3 = 7 << 16;
+                    r6 = r5 << 3;
+                    r3 = r3 + 2176;
+                    r3 = r6 + r3;
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f4 = r9;
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    f5 = r8;
+                    r3 = r20 + 1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f11 = (int)(l >>> 32); f10 = (int)l; }
+                    r6 = fcsr;
+                    r6 = fcsr;
+                    r1 = r6 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f4 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f4 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f4 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f4 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r6;
+                    r7 = f4;
+                    { long l = Double.doubleToLongBits(((double)f4)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r6 = r7 + 48;
+                    addr=r20+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r6 = r0 + 1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r4 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58a44;
+                        run_58a00(); return;
+                    }
+                    f6 = readPages[(r28+-31004)>>>12][((r28+-31004)>>>2)&0x3ff];
+                    r4 = r20 + r4;
+                    f7 = readPages[(r28+-31008)>>>12][((r28+-31008)>>>2)&0x3ff];
+                    r6 = r3 + r0;
+                case 0x589f4:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r6 = r6 + 1;
+                    r8 = fcsr;
+                case 0x58a00:
+                    pc=0x58a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_58a00() throws ExecutionException { /* 0x58a00 - 0x58c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x58a00:
+                    r8 = fcsr;
+                    r1 = r8 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f4 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f4 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f4 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f4 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r8;
+                    r9 = f4;
+                    { long l = Double.doubleToLongBits(((double)f4)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r10 = r9 + 48;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))-(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    addr=r6+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r10&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r6 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x589f4;
+                        run_58800(); return;
+                    }
+                    r3 = r3 + r5;
+                case 0x58a44:
+                    f2 = readPages[(r28+-30980)>>>12][((r28+-30980)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-30984)>>>12][((r28+-30984)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58b40;
+                        continue;
+                    }
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x57d3c;
+                    run_57c00(); return;
+                case 0x58a78:
+                    r21 = r18 - r30;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57dc8;
+                    run_57c00(); return;
+                case 0x58a88:
+                    r2 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r3 = r0 + 54;
+                    r2 = r3 - r2;
+                    r21 = r18 + r0;
+                    r3 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x57dc8;
+                    run_57c00(); return;
+                case 0x58aa4:
+                    f0 = f8;
+                    f1 = f9;
+                    r8 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x578fc;
+                    run_57800(); return;
+                case 0x58ab4:
+                    if(r30 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x586d0;
+                        run_58600(); return;
+                    }
+                    r9 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    if(r9 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58768;
+                        run_58600(); return;
+                    }
+                    f6 = readPages[(r28+-31004)>>>12][((r28+-31004)>>>2)&0x3ff];
+                    r8 = r8 + 1;
+                    f7 = readPages[(r28+-31008)>>>12][((r28+-31008)>>>2)&0x3ff];
+                    f4 = r8;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f7&0xffffffffL) << 32) | (f6&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits(((double)f4)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r3 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r4 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r2 = r3 + -1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f2 = readPages[(r28+-30996)>>>12][((r28+-30996)>>>2)&0x3ff];
+                    r3 = 64704 << 16;
+                    f3 = readPages[(r28+-31000)>>>12][((r28+-31000)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f7 = (int)(l >>> 32); f6 = (int)l; }
+                    r8 = f7;
+                    r9 = f6;
+                    r8 = r3 + r8;
+                    /* Next insn is delay slot */ 
+                    pc=0x5796c;
+                    run_57800(); return;
+                case 0x58b1c:
+                    r8 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r0 + 57;
+                    r18 = r19 + r0;
+                    r3 = r8 + 1;
+                    addr=r8+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = r21 + r0;
+                    r4 = r0 + 57;
+                    /* Next insn is delay slot */ 
+                    pc=0x582b4;
+                    run_58200(); return;
+                case 0x58b40:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f11&0xffffffffL) << 32) | (f10&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58768;
+                        run_58600(); return;
+                    }
+                    r6 = r0 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=0x58b64;
+                    continue;
+                case 0x58b60:
+                    r3 = r5 + r0;
+                case 0x58b64:
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r5 = r3 + -1;
+                    if(r4 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58b60;
+                        continue;
+                    }
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x57ac4;
+                    run_57a00(); return;
+                case 0x58b80:
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x57d3c;
+                    run_57c00(); return;
+                case 0x58b8c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58574;
+                        run_58400(); return;
+                    }
+                    r2 = r23 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x58574;
+                        run_58400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5855c;
+                    run_58400(); return;
+                case 0x58ba8:
+                    r5 = r19 + r0;
+                    r4 = r16 + r0;
+                    r6 = r0 + 10;
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x58bc0;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x58bc0:
+                    r19 = r2 + r0;
+                    r30 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x57f7c;
+                    run_57e00(); return;
+                case 0x58bd0:
+                    r8 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x578fc;
+                    run_57800(); return;
+                case 0x58bdc:
+                    r4 = r0 + 4;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x57f2c;
+                        run_57e00(); return;
+                    }
+                    r3 = r0 + 60;
+                    r2 = r3 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x581dc;
+                    run_58000(); return;
+                case 0x58bf8:
+                    r8 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5778c;
+                    run_57600(); return;
+                case 0x58c00:
+                    pc=0x58c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_58c00() throws ExecutionException { /* 0x58c00 - 0x58e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x58c00:
+                case 0x58c04:
+                    r21 = r6 + r0;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5782c;
+                    run_57800(); return;
+                case 0x58e00:
+                    pc=0x58e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_58e00() throws ExecutionException { /* 0x58e00 - 0x59000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x58e00:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x59000:
+                    pc=0x59000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_59000() throws ExecutionException { /* 0x59000 - 0x59200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x59000:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x59200:
+                    pc=0x59200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_59200() throws ExecutionException { /* 0x59200 - 0x59400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x59200:
+                    r2 = r6 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x593a4;
+                        continue;
+                    }
+                    r29 = r29 + -56;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r22;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r21;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r21 = r4 + r0;
+                    r22 = r5 + r0;
+                    r17 = r7 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59254;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59340;
+                        continue;
+                    }
+                case 0x59254:
+                    r18 = r6 + -1;
+                    r19 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x592d0;
+                    continue;
+                case 0x59264:
+                    r2 = ((r18 & 0xffffffffL) < (r16 & 0xffffffffL)) ? 1 : 0;
+                    r20 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59278;
+                        continue;
+                    }
+                    r16 = r18 + r0;
+                case 0x59278:
+                    r4 = r20 + r0;
+                    r5 = r0 + 10;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5928c;
+                    pc=0x5b400;
+                    run_5b400(); return;
+                case 0x5928c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59358;
+                        continue;
+                    }
+                    r2 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r4 = r19 + r0;
+                    r2 = r2 - r16;
+                    writePages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    r5 = r20 + r0;
+                    r2 = r2 + r16;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    r6 = r16 + r0;
+                    r18 = r18 - r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x592c4;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x592c4:
+                    r19 = r19 + r16;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5930c;
+                        continue;
+                    }
+                case 0x592d0:
+                    r16 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59264;
+                        continue;
+                    }
+                    r4 = r21 + r0;
+                    r5 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x592f0;
+                    pc=0x41200;
+                    run_41200(); return;
+                case 0x592f0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59304;
+                        continue;
+                    }
+                    r16 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x59264;
+                    continue;
+                case 0x59304:
+                    if(r19 == r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59398;
+                        continue;
+                    }
+                case 0x5930c:
+                    addr=r19+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r22 + r0;
+                case 0x59314:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x59340:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x5934c;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x5934c:
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x59254;
+                    continue;
+                case 0x59358:
+                    r2 = r2 + 1;
+                    r3 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r16 = r2 - r20;
+                    r3 = r3 - r16;
+                    r6 = r16 + r0;
+                    writePages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff] = r3;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    r4 = r19 + r0;
+                    r5 = r20 + r0;
+                    r16 = r19 + r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x59388;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x59388:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59314;
+                    continue;
+                case 0x59398:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59314;
+                    continue;
+                case 0x593a4:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x59400:
+                    pc=0x59400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_59400() throws ExecutionException { /* 0x59400 - 0x59600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x59400:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59200;
+                    run_59200(); return;
+                case 0x59600:
+                    pc=0x59600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_59600() throws ExecutionException { /* 0x59600 - 0x59800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x59600:
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 114;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59698;
+                        continue;
+                    }
+                    r3 = r0 + 119;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59684;
+                        continue;
+                    }
+                    r3 = r0 + 97;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5963c;
+                        continue;
+                    }
+                    r2 = r0 + 22;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5963c:
+                    r7 = r0 + 520;
+                    r4 = r0 + 1;
+                    r2 = r0 + 264;
+                case 0x59648:
+                    addr=r5+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59674;
+                        continue;
+                    }
+                    r8 = r0 + 43;
+                    if(r3 == r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x596ac;
+                        continue;
+                    }
+                    addr=r5+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x596ac;
+                        continue;
+                    }
+                case 0x59674:
+                    r4 = r4 | r7;
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x59684:
+                    r7 = r0 + 1536;
+                    r4 = r0 + 1;
+                    r2 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x59648;
+                    continue;
+                case 0x59698:
+                    r7 = r0 + r0;
+                    r4 = r0 + r0;
+                    r2 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x59648;
+                    continue;
+                case 0x596ac:
+                    r3 = r0 + -29;
+                    r4 = r0 + 2;
+                    r2 = r2 & r3;
+                    r4 = r4 | r7;
+                    r2 = r2 | 16;
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x59800:
+                    pc=0x59800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_59800() throws ExecutionException { /* 0x59800 - 0x59a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x59800:
+                    r29 = r29 + -56;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = r5 + r0;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    r16 = r6 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x59828;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x59828:
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r2;
+                    r2 = r29 + 28;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59858;
+                        continue;
+                    }
+                    r2 = readPages[(r17+56)>>>12][((r17+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x598b0;
+                        continue;
+                    }
+                case 0x59858:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r3 = r2 & 8192;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59884;
+                        continue;
+                    }
+                    r2 = r2 | 8192;
+                    r3 = readPages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff];
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -8193;
+                    r2 = r3 & r2;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r2;
+                case 0x59884:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    r6 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x59898;
+                    pc=0x59c00;
+                    run_59c00(); return;
+                case 0x59898:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r17 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r16 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x598b0:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x598bc;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x598bc:
+                    /* Next insn is delay slot */ 
+                    pc=0x59858;
+                    continue;
+                case 0x59a00:
+                    pc=0x59a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_59a00() throws ExecutionException { /* 0x59a00 - 0x59c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x59a00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59800;
+                    run_59800(); return;
+                case 0x59c00:
+                    pc=0x59c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_59c00() throws ExecutionException { /* 0x59c00 - 0x59e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x59c00:
+                    r2 = readPages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff];
+                    r29 = r29 + -64;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r30;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r23;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r22;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r21;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r19 = r6 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59cd4;
+                        continue;
+                    }
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r21 = r4 + r0;
+                    r3 = r2 & 8;
+                    r16 = r5 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59d0c;
+                        continue;
+                    }
+                    r3 = readPages[(r5+16)>>>12][((r5+16)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59d0c;
+                        continue;
+                    }
+                    r3 = r2 & 2;
+                    r17 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59d38;
+                        continue;
+                    }
+                case 0x59c74:
+                    r20 = r0 + r0;
+                    r18 = r0 + r0;
+                case 0x59c7c:
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59dfc;
+                        continue;
+                    }
+                    r2 = (r18&0xffffffffL) < (1025&0xffffffffL) ? 1 : 0;
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r7 = r18 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59c9c;
+                        continue;
+                    }
+                    r7 = r0 + 1024;
+                case 0x59c9c:
+                    r2 = readPages[(r16+36)>>>12][((r16+36)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r6 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x59cb0;
+                    return;
+                case 0x59cb0:
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e3c;
+                        run_59e00(); return;
+                    }
+                    r3 = readPages[(r19+8)>>>12][((r19+8)>>>2)&0x3ff];
+                    r20 = r20 + r2;
+                    r18 = r18 - r2;
+                    r2 = r3 - r2;
+                    writePages[(r19+8)>>>12][((r19+8)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59c7c;
+                        continue;
+                    }
+                case 0x59cd4:
+                    r2 = r0 + r0;
+                case 0x59cd8:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r30 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r23 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r22 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x59d0c:
+                    r4 = r21 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x59d1c;
+                    pc=0x48600;
+                    run_48600(); return;
+                case 0x59d1c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a1ec;
+                        run_5a000(); return;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r17 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    r3 = r2 & 2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59c74;
+                        continue;
+                    }
+                case 0x59d38:
+                    r3 = r2 & 1;
+                    r22 = r0 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e58;
+                        run_59e00(); return;
+                    }
+                    r18 = r0 + r0;
+                case 0x59d4c:
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59de8;
+                        continue;
+                    }
+                case 0x59d54:
+                    r3 = r2 & 512;
+                    r20 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59f38;
+                        run_59e00(); return;
+                    }
+                    r3 = ((r18 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a000;
+                        run_5a000(); return;
+                    }
+                    r3 = r2 & 1152;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a084;
+                        run_5a000(); return;
+                    }
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r23 = r20 + r0;
+                    r30 = r20 + r0;
+                    r20 = r18 + r0;
+                case 0x59d8c:
+                    r5 = r22 + r0;
+                    r6 = r23 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x59d9c;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x59d9c:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r30 = r2 - r30;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r30;
+                    r3 = r2 + r23;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    r2 = r18 + r0;
+                case 0x59dbc:
+                    r22 = r22 + r2;
+                    r18 = r18 - r2;
+                    r2 = readPages[(r19+8)>>>12][((r19+8)>>>2)&0x3ff];
+                    r20 = r2 - r20;
+                    writePages[(r19+8)>>>12][((r19+8)>>>2)&0x3ff] = r20;
+                    if(r20 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59cd4;
+                        continue;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59d54;
+                        continue;
+                    }
+                case 0x59de8:
+                    r22 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    r18 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r17 = r17 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x59d4c;
+                    continue;
+                case 0x59dfc:
+                    r20 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                case 0x59e00:
+                    pc=0x59e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_59e00() throws ExecutionException { /* 0x59e00 - 0x5a000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x59e00:
+                    r18 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r17 = r17 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x59c7c;
+                    run_59c00(); return;
+                case 0x59e10:
+                    /* Next insn is delay slot */ 
+                    r31=0x59e18;
+                    pc=0x40800;
+                    run_40800(); return;
+                case 0x59e18:
+                    r30 = r2 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a110;
+                        run_5a000(); return;
+                    }
+                    r5 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x59e34;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x59e34:
+                    r2 = r0 + 12;
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r2;
+                case 0x59e3c:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 64;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x59cd8;
+                    run_59c00(); return;
+                case 0x59e58:
+                    r3 = r0 + r0;
+                    r30 = r0 + r0;
+                    r18 = r0 + r0;
+                case 0x59e64:
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59f20;
+                        continue;
+                    }
+                case 0x59e6c:
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a054;
+                        run_5a000(); return;
+                    }
+                case 0x59e74:
+                    r2 = ((r18 & 0xffffffffL) < (r22 & 0xffffffffL)) ? 1 : 0;
+                    r23 = r22 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e88;
+                        continue;
+                    }
+                    r23 = r18 + r0;
+                case 0x59e88:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r20 = r23 + r0;
+                    r2 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    r6 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r7 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59eb8;
+                        continue;
+                    }
+                    r8 = r6 + r7;
+                    r2 = r8 < r23 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a13c;
+                        run_5a000(); return;
+                    }
+                case 0x59eb8:
+                    r2 = r23 < r7 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59fa0;
+                        continue;
+                    }
+                    r2 = readPages[(r16+36)>>>12][((r16+36)>>>2)&0x3ff];
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r6 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x59ee0;
+                    return;
+                case 0x59ee0:
+                    r20 = r2 + r0;
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e3c;
+                        continue;
+                    }
+                case 0x59ef0:
+                    r22 = r22 - r20;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59fdc;
+                        continue;
+                    }
+                case 0x59efc:
+                    r2 = readPages[(r19+8)>>>12][((r19+8)>>>2)&0x3ff];
+                    r30 = r30 + r20;
+                    r18 = r18 - r20;
+                    r20 = r2 - r20;
+                    writePages[(r19+8)>>>12][((r19+8)>>>2)&0x3ff] = r20;
+                    if(r20 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59cd4;
+                        run_59c00(); return;
+                    }
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e6c;
+                        continue;
+                    }
+                case 0x59f20:
+                    r30 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    r18 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r3 = r0 + r0;
+                    r17 = r17 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x59e64;
+                    continue;
+                case 0x59f38:
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r2 = ((r2 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59f5c;
+                        continue;
+                    }
+                    r2 = ((r20 & 0xffffffffL) < (r18 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a190;
+                        run_5a000(); return;
+                    }
+                case 0x59f5c:
+                    r7 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r2 = ((r18 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a018;
+                        run_5a000(); return;
+                    }
+                    r2 = readPages[(r16+36)>>>12][((r16+36)>>>2)&0x3ff];
+                    r5 = readPages[(r16+28)>>>12][((r16+28)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r6 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x59f88;
+                    return;
+                case 0x59f88:
+                    r20 = r2 + r0;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e3c;
+                        continue;
+                    }
+                    r2 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59dbc;
+                    run_59c00(); return;
+                case 0x59fa0:
+                    r6 = r23 + r0;
+                    r5 = r30 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x59fb4;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x59fb4:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r22 = r22 - r20;
+                    r2 = r2 - r23;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r23 = r2 + r23;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r23;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59efc;
+                        continue;
+                    }
+                case 0x59fdc:
+                    r4 = r21 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x59fec;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x59fec:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e3c;
+                        continue;
+                    }
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59efc;
+                    continue;
+                case 0x5a000:
+                    pc=0x5a000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5a000() throws ExecutionException { /* 0x5a000 - 0x5a200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5a000:
+                    r30 = r18 + r0;
+                    r4 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r20 = r18 + r0;
+                    r23 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59d8c;
+                    run_59c00(); return;
+                case 0x5a018:
+                    r5 = r22 + r0;
+                    r6 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a028;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x5a028:
+                    r2 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r20 = r18 + r0;
+                    r2 = r2 - r18;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r2 = r2 + r18;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r2 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59dbc;
+                    run_59c00(); return;
+                case 0x5a054:
+                    r4 = r30 + r0;
+                    r5 = r0 + 10;
+                    r6 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a068;
+                    pc=0x5b400;
+                    run_5b400(); return;
+                case 0x5a068:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a1dc;
+                        continue;
+                    }
+                    r22 = r2 + 1;
+                    r22 = r22 - r30;
+                    r3 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x59e74;
+                    run_59e00(); return;
+                case 0x5a084:
+                    r4 = readPages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff];
+                    r5 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r6 = r4 << 1;
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r4 = r6 + r4;
+                    r20 = r4 >>> 31;
+                    r23 = r3 - r5;
+                    r4 = r20 + r4;
+                    r6 = r23 + 1;
+                    r20 = r4 >> 1;
+                    r6 = r6 + r18;
+                    r4 = ((r20 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a1d0;
+                        continue;
+                    }
+                    r20 = r6 + r0;
+                case 0x5a0c0:
+                    r2 = r2 & 1024;
+                    r4 = r21 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e10;
+                        run_59e00(); return;
+                    }
+                    r5 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a0dc;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x5a0dc:
+                    r30 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e34;
+                        run_59e00(); return;
+                    }
+                    r5 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    r6 = r23 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a0fc;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x5a0fc:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r0 + -1153;
+                    r2 = r2 & r3;
+                    r2 = r2 | 128;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x5a110:
+                    r4 = r30 + r23;
+                    r3 = r20 - r23;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r30;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r20;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r4;
+                    r30 = r18 + r0;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r3;
+                    r20 = r18 + r0;
+                    r23 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59d8c;
+                    run_59c00(); return;
+                case 0x5a13c:
+                    r6 = r8 + r0;
+                    r5 = r30 + r0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r8;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a154;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x5a154:
+                    r8 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r2 = r2 + r8;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a174;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x5a174:
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r8 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e3c;
+                        run_59e00(); return;
+                    }
+                    r20 = r8 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59ef0;
+                    run_59e00(); return;
+                case 0x5a190:
+                    r5 = r22 + r0;
+                    r6 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a1a0;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x5a1a0:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r4 = r21 + r0;
+                    r2 = r2 + r20;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a1bc;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x5a1bc:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x59e3c;
+                        run_59e00(); return;
+                    }
+                    r2 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x59dbc;
+                    run_59c00(); return;
+                case 0x5a1d0:
+                    r6 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5a0c0;
+                    continue;
+                case 0x5a1dc:
+                    r22 = r18 + 1;
+                    r3 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x59e74;
+                    run_59e00(); return;
+                case 0x5a1ec:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x59cd8;
+                    run_59c00(); return;
+                case 0x5a200:
+                    pc=0x5a200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5a200() throws ExecutionException { /* 0x5a200 - 0x5a400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5a200:
+                    /* Next insn is delay slot */ 
+                    pc=0x65400;
+                    run_65400(); return;
+                case 0x5a400:
+                    pc=0x5a400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5a400() throws ExecutionException { /* 0x5a400 - 0x5a600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5a400:
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r16 = r6 + r0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a438;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r6 + r0;
+                    r5 = r5 + 2076;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a430;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x5a430:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a45c;
+                        continue;
+                    }
+                case 0x5a438:
+                    r17 = 7 << 16;
+                case 0x5a43c:
+                    r17 = r17 + 208;
+                case 0x5a440:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r17 + r0;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5a45c:
+                    r17 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r17 + 208;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a470;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x5a470:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a43c;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r4 = r16 + r0;
+                    r5 = r5 + -12264;
+                    /* Next insn is delay slot */ 
+                    r31=0x5a48c;
+                    pc=0x42c00;
+                    run_42c00(); return;
+                case 0x5a48c:
+                    r17 = r17 + 208;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5a440;
+                        continue;
+                    }
+                    r17 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5a440;
+                    continue;
+                case 0x5a600:
+                    pc=0x5a600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5a600() throws ExecutionException { /* 0x5a600 - 0x5a800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5a600:
+                    r2 = 7 << 16;
+                    r2 = r2 + 12168;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5a800:
+                    pc=0x5a800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5a800() throws ExecutionException { /* 0x5a800 - 0x5aa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5a800:
+                    r2 = readPages[(r28+-30976)>>>12][((r28+-30976)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5aa00:
+                    pc=0x5aa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5aa00() throws ExecutionException { /* 0x5aa00 - 0x5ac00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5aa00:
+                    r2 = 7 << 16;
+                    r2 = r2 + 12136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5ac00:
+                    pc=0x5ac00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5ac00() throws ExecutionException { /* 0x5ac00 - 0x5ae00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5ac00:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5ae00:
+                    pc=0x5ae00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5ae00() throws ExecutionException { /* 0x5ae00 - 0x5b000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5ae00:
+                    r2 = 7 << 16;
+                    r2 = r2 + 12200;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5b000:
+                    pc=0x5b000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5b000() throws ExecutionException { /* 0x5b000 - 0x5b200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5b000:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5a400;
+                    run_5a400(); return;
+                case 0x5b200:
+                    pc=0x5b200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5b200() throws ExecutionException { /* 0x5b200 - 0x5b400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5b200:
+                    r2 = 7 << 16;
+                    r2 = r2 + 12200;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5b400:
+                    pc=0x5b400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5b400() throws ExecutionException { /* 0x5b400 - 0x5b600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5b400:
+                    r2 = r4 & 3;
+                    r7 = r5 & 255;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b45c;
+                        continue;
+                    }
+                    r2 = r6 + -1;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b440;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5b4b0;
+                    continue;
+                case 0x5b424:
+                    r4 = r4 + 1;
+                    r3 = r4 & 3;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b460;
+                        continue;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b4b0;
+                        continue;
+                    }
+                    r2 = r2 + -1;
+                case 0x5b440:
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    if(r3 != r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b424;
+                        continue;
+                    }
+                case 0x5b450:
+                    r2 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5b45c:
+                    r2 = r6 + r0;
+                case 0x5b460:
+                    r3 = (r2&0xffffffffL) < (4&0xffffffffL) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b4bc;
+                        continue;
+                    }
+                case 0x5b46c:
+                    r5 = r2 + -1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b4b0;
+                        continue;
+                    }
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b450;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5b4a4;
+                    continue;
+                case 0x5b494:
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r2 + 1;
+                    if(r3 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b450;
+                        continue;
+                    }
+                case 0x5b4a4:
+                    r4 = r4 + 1;
+                    if(r2 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b494;
+                        continue;
+                    }
+                case 0x5b4b0:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5b4bc:
+                    r5 = r5 & 255;
+                    r3 = r5 << 8;
+                    r3 = r3 | r5;
+                    r9 = r3 << 16;
+                    r8 = 65278 << 16;
+                    r6 = 32896 << 16;
+                    r9 = r9 | r3;
+                    r8 = r8 | 65279;
+                    r6 = r6 | 32896;
+                case 0x5b4e0:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r3 = r9 ^ r3;
+                    r5 = r3 + r8;
+                    r3 = ~(r0 | r3);
+                    r3 = r5 & r3;
+                    r3 = r3 & r6;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b46c;
+                        continue;
+                    }
+                    r2 = r2 + -4;
+                    r3 = (r2&0xffffffffL) < (4&0xffffffffL) ? 1 : 0;
+                    r4 = r4 + 4;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b4e0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5b46c;
+                    continue;
+                case 0x5b600:
+                    pc=0x5b600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5b600() throws ExecutionException { /* 0x5b600 - 0x5b800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5b600:
+                    r3 = ((r5 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    r2 = r4 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b650;
+                        continue;
+                    }
+                    r7 = r5 + r6;
+                    r3 = ((r4 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b650;
+                        continue;
+                    }
+                    r3 = r4 + r6;
+                    r5 = r3 - r6;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b748;
+                        continue;
+                    }
+                case 0x5b630:
+                    r7 = r7 + -1;
+                    addr=r7+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r3 = r3 + -1;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r3 != r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b630;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5b650:
+                    r3 = (r6&0xffffffffL) < (16&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b750;
+                        continue;
+                    }
+                    r3 = r2 | r5;
+                    r3 = r3 & 3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b764;
+                        continue;
+                    }
+                    r7 = r5 + r0;
+                    r3 = r2 + r0;
+                    r4 = r6 + r0;
+                case 0x5b678:
+                    r8 = readPages[(r7+0)>>>12][((r7+0)>>>2)&0x3ff];
+                    r7 = r7 + 16;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r8;
+                    r8 = readPages[(r7+-12)>>>12][((r7+-12)>>>2)&0x3ff];
+                    r3 = r3 + 16;
+                    writePages[(r3+-12)>>>12][((r3+-12)>>>2)&0x3ff] = r8;
+                    r8 = readPages[(r7+-8)>>>12][((r7+-8)>>>2)&0x3ff];
+                    r4 = r4 + -16;
+                    writePages[(r3+-8)>>>12][((r3+-8)>>>2)&0x3ff] = r8;
+                    r8 = readPages[(r7+-4)>>>12][((r7+-4)>>>2)&0x3ff];
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r8;
+                    r8 = (r4&0xffffffffL) < (16&0xffffffffL) ? 1 : 0;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b678;
+                        continue;
+                    }
+                    r4 = r6 + -16;
+                    r4 = r4 >>> 4;
+                    r4 = r4 + 1;
+                    r4 = r4 << 4;
+                    r10 = r6 & 15;
+                    r3 = r2 + r4;
+                    r5 = r5 + r4;
+                    r4 = (r10&0xffffffffL) < (4&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b778;
+                        continue;
+                    }
+                    r8 = r5 + r0;
+                    r7 = r3 + r0;
+                    r4 = r10 + r0;
+                case 0x5b6e8:
+                    r8 = r8 + 4;
+                    r9 = readPages[(r8+-4)>>>12][((r8+-4)>>>2)&0x3ff];
+                    r7 = r7 + 4;
+                    r4 = r4 + -4;
+                    writePages[(r7+-4)>>>12][((r7+-4)>>>2)&0x3ff] = r9;
+                    r9 = (r4&0xffffffffL) < (4&0xffffffffL) ? 1 : 0;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b6e8;
+                        continue;
+                    }
+                    r4 = r10 + -4;
+                    r4 = r4 >>> 2;
+                    r4 = r4 + 1;
+                    r4 = r4 << 2;
+                    r6 = r6 & 3;
+                    r3 = r3 + r4;
+                    r5 = r5 + r4;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b770;
+                        continue;
+                    }
+                case 0x5b72c:
+                    r6 = r3 + r6;
+                case 0x5b730:
+                    r5 = r5 + 1;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r7 = tmp;
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r7&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r3 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b730;
+                        continue;
+                    }
+                case 0x5b748:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5b750:
+                    r3 = r2 + r0;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b72c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5b770;
+                    continue;
+                case 0x5b764:
+                    r3 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5b72c;
+                    continue;
+                case 0x5b770:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5b778:
+                    r6 = r10 + r0;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b72c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5b770;
+                    continue;
+                case 0x5b800:
+                    pc=0x5b800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5b800() throws ExecutionException { /* 0x5b800 - 0x5ba00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5b800:
+                    r2 = readPages[(r4+76)>>>12][((r4+76)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    r16 = r4 + r0;
+                    r17 = r5 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b870;
+                        continue;
+                    }
+                case 0x5b828:
+                    r3 = r17 << 2;
+                    r3 = r2 + r3;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b898;
+                        continue;
+                    }
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                case 0x5b84c:
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r0;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                case 0x5b854:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5b870:
+                    r5 = r0 + 4;
+                    r6 = r0 + 33;
+                    /* Next insn is delay slot */ 
+                    r31=0x5b880;
+                    pc=0x65600;
+                    run_65600(); return;
+                case 0x5b880:
+                    writePages[(r16+76)>>>12][((r16+76)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b828;
+                        continue;
+                    }
+                case 0x5b88c:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5b854;
+                    continue;
+                case 0x5b898:
+                    r18 = r0 + 1;
+                    r18 = r18 << (r17&0x1f);
+                    r6 = r18 + 5;
+                    r4 = r16 + r0;
+                    r5 = r0 + 1;
+                    r6 = r6 << 2;
+                    /* Next insn is delay slot */ 
+                    r31=0x5b8b8;
+                    pc=0x65600;
+                    run_65600(); return;
+                case 0x5b8b8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5b88c;
+                        continue;
+                    }
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r17;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x5b84c;
+                    continue;
+                case 0x5ba00:
+                    pc=0x5ba00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5ba00() throws ExecutionException { /* 0x5ba00 - 0x5bc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5ba00:
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ba28;
+                        continue;
+                    }
+                    r2 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    r3 = readPages[(r4+76)>>>12][((r4+76)>>>2)&0x3ff];
+                    r2 = r2 << 2;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    writePages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff] = r3;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r5;
+                case 0x5ba28:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5bc00:
+                    pc=0x5bc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5bc00() throws ExecutionException { /* 0x5bc00 - 0x5be00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5bc00:
+                    r29 = r29 + -48;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r5+16)>>>12][((r5+16)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    r18 = r4 + r0;
+                    r17 = r5 + r0;
+                    r3 = r5 + 20;
+                    r8 = r0 + r0;
+                case 0x5bc2c:
+                    r11 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r8 = r8 + 1;
+                    r9 = r11 & 65535;
+                    { long hilo = (long)(r9) * ((long)r6); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r11 = r11 >>> 16;
+                    r3 = r3 + 4;
+                    r9 = lo;
+                    r9 = r9 + r7;
+                    r7 = r9 >>> 16;
+                    { long hilo = (long)(r11) * ((long)r6); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r9 = r9 & 65535;
+                    r11 = lo;
+                    r10 = r7 + r11;
+                    r7 = r10 >>> 16;
+                    r10 = r10 << 16;
+                    r9 = r10 + r9;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r9;
+                    r9 = r8 < r16 ? 1 : 0;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5bc2c;
+                        continue;
+                    }
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5bcb0;
+                        continue;
+                    }
+                    r2 = readPages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff];
+                    r2 = r16 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5bcd4;
+                        continue;
+                    }
+                case 0x5bc98:
+                    r2 = r16 + 4;
+                    r2 = r2 << 2;
+                    r2 = r17 + r2;
+                    r16 = r16 + 1;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r7;
+                    writePages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff] = r16;
+                case 0x5bcb0:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r17 + r0;
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5bcd4:
+                    r5 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    r5 = r5 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x5bcec;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5bcec:
+                    r6 = readPages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff];
+                    r5 = r17 + 12;
+                    r6 = r6 + 2;
+                    r4 = r2 + 12;
+                    r6 = r6 << 2;
+                    r19 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5bd0c;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x5bd0c:
+                    r2 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    r3 = readPages[(r18+76)>>>12][((r18+76)>>>2)&0x3ff];
+                    r2 = r2 << 2;
+                    r2 = r3 + r2;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r7 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r3;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r17;
+                    r17 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5bc98;
+                    continue;
+                case 0x5be00:
+                    pc=0x5be00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5be00() throws ExecutionException { /* 0x5be00 - 0x5c000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5be00:
+                    r29 = r29 + -48;
+                    r2 = r0 + 9;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = r7 + 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        hi = r4%r2; lo = r4/r2;
+                        pc=0x5be20;
+                        continue;
+                    }
+                    hi = r4%r2; lo = r4/r2;
+                    throw new ExecutionException("Break");
+                case 0x5be20:
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r21;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r20 = r5 + r0;
+                    r18 = r6 + r0;
+                    r19 = r7 + r0;
+                    r4 = lo;
+                    r2 = r4 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5bf4c;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    r5 = r0 + r0;
+                case 0x5be5c:
+                    r2 = r2 << 1;
+                    r8 = r2 < r4 ? 1 : 0;
+                    r5 = r5 + 1;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5be5c;
+                        continue;
+                    }
+                case 0x5be70:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5be7c;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5be7c:
+                    r3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    writePages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 1;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    r3 = r18 < 10 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5bf3c;
+                        continue;
+                    }
+                    r21 = r20 + 9;
+                    r16 = r21 + r0;
+                    r20 = r20 + r18;
+                case 0x5bea8:
+                    r16 = r16 + 1;
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r7 = tmp;
+                    r4 = r17 + r0;
+                    r5 = r2 + r0;
+                    r6 = r0 + 10;
+                    r7 = r7 + -48;
+                    /* Next insn is delay slot */ 
+                    r31=0x5bec8;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x5bec8:
+                    if(r16 != r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5bea8;
+                        continue;
+                    }
+                    r16 = r21 + r18;
+                    r16 = r16 + -8;
+                case 0x5bed8:
+                    r3 = r18 < r19 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5bf14;
+                        continue;
+                    }
+                    r18 = r19 - r18;
+                    r18 = r16 + r18;
+                case 0x5beec:
+                    r16 = r16 + 1;
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r7 = tmp;
+                    r4 = r17 + r0;
+                    r5 = r2 + r0;
+                    r6 = r0 + 10;
+                    r7 = r7 + -48;
+                    /* Next insn is delay slot */ 
+                    r31=0x5bf0c;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x5bf0c:
+                    if(r16 != r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5beec;
+                        continue;
+                    }
+                case 0x5bf14:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r21 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5bf3c:
+                    r16 = r20 + 10;
+                    r18 = r0 + 9;
+                    /* Next insn is delay slot */ 
+                    pc=0x5bed8;
+                    continue;
+                case 0x5bf4c:
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5be70;
+                    continue;
+                case 0x5c000:
+                    pc=0x5c000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5c000() throws ExecutionException { /* 0x5c000 - 0x5c200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5c000:
+                    r2 = 65535 << 16;
+                    r2 = r4 & r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c084;
+                        continue;
+                    }
+                    r4 = r4 << 16;
+                    r2 = r0 + 16;
+                case 0x5c018:
+                    r3 = 65280 << 16;
+                    r3 = r4 & r3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c030;
+                        continue;
+                    }
+                    r2 = r2 + 8;
+                    r4 = r4 << 8;
+                case 0x5c030:
+                    r3 = 61440 << 16;
+                    r3 = r4 & r3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c048;
+                        continue;
+                    }
+                    r2 = r2 + 4;
+                    r4 = r4 << 4;
+                case 0x5c048:
+                    r3 = 49152 << 16;
+                    r3 = r4 & r3;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c060;
+                        continue;
+                    }
+                    r2 = r2 + 2;
+                    r4 = r4 << 2;
+                case 0x5c060:
+                    if(r4 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c07c;
+                        continue;
+                    }
+                    r3 = 16384 << 16;
+                    r4 = r4 & r3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c090;
+                        continue;
+                    }
+                    r2 = r0 + 32;
+                case 0x5c07c:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5c084:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5c018;
+                    continue;
+                case 0x5c090:
+                    r2 = r2 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5c200:
+                    pc=0x5c200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5c200() throws ExecutionException { /* 0x5c200 - 0x5c400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5c200:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r3 & 7;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c240;
+                        continue;
+                    }
+                    r2 = r3 & 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c2d0;
+                        continue;
+                    }
+                    r2 = r3 & 2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c2dc;
+                        continue;
+                    }
+                    r3 = r3 >>> 2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5c240:
+                    r2 = r3 & 65535;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c2b0;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                case 0x5c250:
+                    r5 = r3 & 255;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c264;
+                        continue;
+                    }
+                    r2 = r2 + 8;
+                    r3 = r3 >>> 8;
+                case 0x5c264:
+                    r5 = r3 & 15;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c278;
+                        continue;
+                    }
+                    r2 = r2 + 4;
+                    r3 = r3 >>> 4;
+                case 0x5c278:
+                    r5 = r3 & 3;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c28c;
+                        continue;
+                    }
+                    r2 = r2 + 2;
+                    r3 = r3 >>> 2;
+                case 0x5c28c:
+                    r5 = r3 & 1;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c2c4;
+                        continue;
+                    }
+                    r3 = r3 >>> 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c2c0;
+                        continue;
+                    }
+                    r2 = r0 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5c2b0:
+                    r3 = r3 >>> 16;
+                    r2 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x5c250;
+                    continue;
+                case 0x5c2c0:
+                    r2 = r2 + 1;
+                case 0x5c2c4:
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5c2d0:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5c2dc:
+                    r3 = r3 >>> 1;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5c400:
+                    pc=0x5c400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5c400() throws ExecutionException { /* 0x5c400 - 0x5c600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5c400:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r5 + r0;
+                    r5 = r0 + 1;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x5c41c;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5c41c:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    writePages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff] = r16;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r4;
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5c600:
+                    pc=0x5c600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5c600() throws ExecutionException { /* 0x5c600 - 0x5c800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5c600:
+                    r29 = r29 + -40;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    r19 = readPages[(r6+16)>>>12][((r6+16)>>>2)&0x3ff];
+                    r18 = readPages[(r5+16)>>>12][((r5+16)>>>2)&0x3ff];
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    r2 = r18 < r19 ? 1 : 0;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r17 = r5 + r0;
+                    r20 = r6 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c64c;
+                        continue;
+                    }
+                    r2 = r18 + r0;
+                    r17 = r6 + r0;
+                    r18 = r19 + r0;
+                    r20 = r5 + r0;
+                    r19 = r2 + r0;
+                case 0x5c64c:
+                    r2 = readPages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff];
+                    r16 = r18 + r19;
+                    r2 = r2 < r16 ? 1 : 0;
+                    r5 = readPages[(r17+4)>>>12][((r17+4)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c668;
+                        continue;
+                    }
+                    r5 = r5 + 1;
+                case 0x5c668:
+                    /* Next insn is delay slot */ 
+                    r31=0x5c670;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5c670:
+                    r13 = r2 + 20;
+                    r14 = r16 << 2;
+                    r14 = r13 + r14;
+                    r4 = ((r13 & 0xffffffffL) < (r14 & 0xffffffffL)) ? 1 : 0;
+                    r3 = r13 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c6a0;
+                        continue;
+                    }
+                case 0x5c68c:
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r0;
+                    r3 = r3 + 4;
+                    r4 = ((r3 & 0xffffffffL) < (r14 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c68c;
+                        continue;
+                    }
+                case 0x5c6a0:
+                    r12 = r20 + 20;
+                    r15 = r19 << 2;
+                    r15 = r12 + r15;
+                    r24 = r17 + 20;
+                    r11 = r18 << 2;
+                    r3 = ((r12 & 0xffffffffL) < (r15 & 0xffffffffL)) ? 1 : 0;
+                    r11 = r24 + r11;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c804;
+                        run_5c800(); return;
+                    }
+                case 0x5c6c4:
+                    r9 = readPages[(r12+0)>>>12][((r12+0)>>>2)&0x3ff];
+                    r8 = r9 & 65535;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c760;
+                        continue;
+                    }
+                    r4 = r13 + r0;
+                    r3 = r24 + r0;
+                    r9 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5c6f0;
+                    continue;
+                case 0x5c6ec:
+                    r4 = r7 + r0;
+                case 0x5c6f0:
+                    r6 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r7 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r5 = r6 & 65535;
+                    { long hilo = (long)(r5) * ((long)r8); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r6 = r6 >>> 16;
+                    r10 = r7 & 65535;
+                    r7 = r7 >>> 16;
+                    r3 = r3 + 4;
+                    r5 = lo;
+                    r5 = r5 + r10;
+                    r5 = r5 + r9;
+                    { long hilo = (long)(r6) * ((long)r8); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r9 = r5 >>> 16;
+                    r5 = r5 & 65535;
+                    r6 = lo;
+                    r6 = r6 + r7;
+                    r6 = r6 + r9;
+                    r9 = r6 >>> 16;
+                    r6 = r6 << 16;
+                    r5 = r6 | r5;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r5;
+                    r5 = ((r3 & 0xffffffffL) < (r11 & 0xffffffffL)) ? 1 : 0;
+                    r7 = r4 + 4;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c6ec;
+                        continue;
+                    }
+                    writePages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff] = r9;
+                    r9 = readPages[(r12+0)>>>12][((r12+0)>>>2)&0x3ff];
+                case 0x5c760:
+                    r9 = r9 >>> 16;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c7f0;
+                        continue;
+                    }
+                    r4 = readPages[(r13+0)>>>12][((r13+0)>>>2)&0x3ff];
+                    r5 = r13 + r0;
+                    r7 = r4 + r0;
+                    r3 = r24 + r0;
+                    r10 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5c78c;
+                    continue;
+                case 0x5c788:
+                    r5 = r8 + r0;
+                case 0x5c78c:
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r6 = tmp;
+                    r7 = r7 >>> 16;
+                    { long hilo = (long)(r6) * ((long)r9); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r4 = r4 & 65535;
+                    r3 = r3 + 4;
+                    r8 = r5 + 4;
+                    r6 = lo;
+                    r6 = r6 + r7;
+                    r6 = r6 + r10;
+                    r7 = r6 << 16;
+                    r4 = r7 | r4;
+                    writePages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff] = r4;
+                    addr=r3+-4;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r4 = tmp;
+                    r7 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    { long hilo = (long)(r4) * ((long)r9); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r10 = r7 & 65535;
+                    r6 = r6 >>> 16;
+                    r4 = lo;
+                    r4 = r4 + r10;
+                    r4 = r4 + r6;
+                    r6 = ((r3 & 0xffffffffL) < (r11 & 0xffffffffL)) ? 1 : 0;
+                    r10 = r4 >>> 16;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c788;
+                        continue;
+                    }
+                    writePages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff] = r4;
+                case 0x5c7f0:
+                    r12 = r12 + 4;
+                    r3 = ((r12 & 0xffffffffL) < (r15 & 0xffffffffL)) ? 1 : 0;
+                    r13 = r13 + 4;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c6c4;
+                        continue;
+                    }
+                case 0x5c800:
+                    pc=0x5c800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5c800() throws ExecutionException { /* 0x5c800 - 0x5ca00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5c800:
+                case 0x5c804:
+                    if(r16 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c844;
+                        continue;
+                    }
+                    r4 = readPages[(r14+-4)>>>12][((r14+-4)>>>2)&0x3ff];
+                    r3 = r14 + -4;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c838;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5c844;
+                    continue;
+                case 0x5c824:
+                    r3 = r3 + -4;
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c844;
+                        continue;
+                    }
+                case 0x5c838:
+                    r16 = r16 + -1;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5c824;
+                        continue;
+                    }
+                case 0x5c844:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r16;
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5ca00:
+                    pc=0x5ca00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5ca00() throws ExecutionException { /* 0x5ca00 - 0x5cc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5ca00:
+                    r29 = r29 + -40;
+                    r2 = r6 & 3;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r19 = r4 + r0;
+                    r18 = r5 + r0;
+                    r16 = r6 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cb24;
+                        continue;
+                    }
+                case 0x5ca30:
+                    r16 = r16 >> 2;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cacc;
+                        continue;
+                    }
+                    r17 = readPages[(r19+72)>>>12][((r19+72)>>>2)&0x3ff];
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cb54;
+                        continue;
+                    }
+                case 0x5ca4c:
+                    r3 = r16 & 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ca84;
+                        continue;
+                    }
+                case 0x5ca58:
+                    r16 = r16 >> 1;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cacc;
+                        continue;
+                    }
+                case 0x5ca64:
+                    r2 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5caf0;
+                        continue;
+                    }
+                    r17 = r2 + r0;
+                case 0x5ca78:
+                    r3 = r16 & 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ca58;
+                        continue;
+                    }
+                case 0x5ca84:
+                    r4 = r19 + r0;
+                    r5 = r18 + r0;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5ca98;
+                    pc=0x5c600;
+                    run_5c600(); return;
+                case 0x5ca98:
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cb18;
+                        continue;
+                    }
+                    r3 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    r4 = readPages[(r19+76)>>>12][((r19+76)>>>2)&0x3ff];
+                    r3 = r3 << 2;
+                    r3 = r4 + r3;
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r16 = r16 >> 1;
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r4;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r18;
+                    r18 = r2 + r0;
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ca64;
+                        continue;
+                    }
+                case 0x5cacc:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r2 = r18 + r0;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5caf0:
+                    r5 = r17 + r0;
+                    r6 = r17 + r0;
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5cb04;
+                    pc=0x5c600;
+                    run_5c600(); return;
+                case 0x5cb04:
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5ca78;
+                    continue;
+                case 0x5cb18:
+                    r18 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5ca58;
+                    continue;
+                case 0x5cb24:
+                    r2 = r2 + -1;
+                    r3 = 7 << 16;
+                    r3 = r3 + 2084;
+                    r2 = r2 << 2;
+                    r2 = r2 + r3;
+                    r6 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r7 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5cb48;
+                    pc=0x5bc00;
+                    run_5bc00(); return;
+                case 0x5cb48:
+                    r18 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5ca30;
+                    continue;
+                case 0x5cb54:
+                    r4 = r19 + r0;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x5cb64;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5cb64:
+                    r17 = r2 + r0;
+                    r2 = r0 + 625;
+                    writePages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff] = r2;
+                    writePages[(r19+72)>>>12][((r19+72)>>>2)&0x3ff] = r17;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5ca4c;
+                    continue;
+                case 0x5cc00:
+                    pc=0x5cc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5cc00() throws ExecutionException { /* 0x5cc00 - 0x5ce00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5cc00:
+                    r29 = r29 + -48;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    r18 = r5 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r20;
+                    r20 = readPages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r17 = r6 >> 5;
+                    r20 = r17 + r20;
+                    r2 = readPages[(r18+8)>>>12][((r18+8)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r16 = r20 + 1;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r19 = r4 + r0;
+                    r4 = r2 < r16 ? 1 : 0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    r21 = r6 + r0;
+                    r5 = readPages[(r5+4)>>>12][((r5+4)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cc64;
+                        continue;
+                    }
+                case 0x5cc50:
+                    r2 = r2 << 1;
+                    r7 = r2 < r16 ? 1 : 0;
+                    r5 = r5 + 1;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cc50;
+                        continue;
+                    }
+                case 0x5cc64:
+                    r4 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5cc70;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5cc70:
+                    r7 = r2 + 20;
+                    if(r17 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cca0;
+                        continue;
+                    }
+                    r8 = r7 + r0;
+                    r3 = r0 + r0;
+                case 0x5cc84:
+                    r8 = r8 + 4;
+                    r3 = r3 + 1;
+                    writePages[(r8+-4)>>>12][((r8+-4)>>>2)&0x3ff] = r0;
+                    if(r3 != r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cc84;
+                        continue;
+                    }
+                    r3 = r3 << 2;
+                    r7 = r7 + r3;
+                case 0x5cca0:
+                    r10 = readPages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff];
+                    r3 = r18 + 20;
+                    r10 = r10 << 2;
+                    r6 = r21 & 31;
+                    r10 = r3 + r10;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cd5c;
+                        continue;
+                    }
+                    r4 = r0 + 32;
+                    r4 = r4 - r6;
+                    r9 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5ccd4;
+                    continue;
+                case 0x5ccd0:
+                    r7 = r8 + r0;
+                case 0x5ccd4:
+                    r11 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    r11 = r11 << (r6&0x1f);
+                    r9 = r9 | r11;
+                    writePages[(r7+0)>>>12][((r7+0)>>>2)&0x3ff] = r9;
+                    r9 = readPages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff];
+                    r11 = ((r3 & 0xffffffffL) < (r10 & 0xffffffffL)) ? 1 : 0;
+                    r8 = r7 + 4;
+                    r9 = r9 >>> (r4&0x1f);
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ccd0;
+                        continue;
+                    }
+                    writePages[(r7+4)>>>12][((r7+4)>>>2)&0x3ff] = r9;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cd10;
+                        continue;
+                    }
+                    r16 = r20 + 2;
+                case 0x5cd10:
+                    r3 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    r4 = readPages[(r19+76)>>>12][((r19+76)>>>2)&0x3ff];
+                    r3 = r3 << 2;
+                    r3 = r4 + r3;
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = r16 + -1;
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r16;
+                    r21 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r4;
+                    r20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r18;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5cd5c:
+                    r3 = r3 + 4;
+                    r6 = readPages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff];
+                    r7 = r7 + 4;
+                    writePages[(r7+-4)>>>12][((r7+-4)>>>2)&0x3ff] = r6;
+                    r6 = ((r3 & 0xffffffffL) < (r10 & 0xffffffffL)) ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cd10;
+                        continue;
+                    }
+                    r3 = r3 + 4;
+                    r6 = readPages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff];
+                    r7 = r7 + 4;
+                    writePages[(r7+-4)>>>12][((r7+-4)>>>2)&0x3ff] = r6;
+                    r6 = ((r3 & 0xffffffffL) < (r10 & 0xffffffffL)) ? 1 : 0;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5cd5c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5cd10;
+                    continue;
+                case 0x5ce00:
+                    pc=0x5ce00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5ce00() throws ExecutionException { /* 0x5ce00 - 0x5d000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5ce00:
+                    r2 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r3 = readPages[(r5+16)>>>12][((r5+16)>>>2)&0x3ff];
+                    r2 = r2 - r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ce78;
+                        continue;
+                    }
+                    r3 = r3 << 2;
+                    r4 = r4 + 20;
+                    r5 = r5 + 20;
+                    r2 = r4 + r3;
+                    r5 = r5 + r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x5ce40;
+                    continue;
+                case 0x5ce34:
+                    r3 = ((r4 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ce74;
+                        continue;
+                    }
+                case 0x5ce40:
+                    r2 = r2 + -4;
+                    r5 = r5 + -4;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r6 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    if(r3 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ce34;
+                        continue;
+                    }
+                    r3 = ((r3 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ce80;
+                        continue;
+                    }
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5ce74:
+                    r2 = r0 + r0;
+                case 0x5ce78:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5ce80:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d000:
+                    pc=0x5d000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5d000() throws ExecutionException { /* 0x5d000 - 0x5d200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5d000:
+                    r29 = r29 + -40;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r18 = r4 + r0;
+                    r16 = r5 + r0;
+                    r4 = r5 + r0;
+                    r5 = r6 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    r17 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d034;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x5d034:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d1a4;
+                        continue;
+                    }
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d18c;
+                        continue;
+                    }
+                    r19 = r0 + r0;
+                case 0x5d048:
+                    r5 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d058;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5d058:
+                    r10 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r13 = readPages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff];
+                    r4 = r16 + 20;
+                    r12 = r10 << 2;
+                    r7 = r17 + 20;
+                    r13 = r13 << 2;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r19;
+                    r12 = r4 + r12;
+                    r13 = r7 + r13;
+                    r3 = r2 + 20;
+                    r5 = r0 + r0;
+                case 0x5d084:
+                    r8 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r9 = readPages[(r7+0)>>>12][((r7+0)>>>2)&0x3ff];
+                    r6 = r8 & 65535;
+                    r5 = r6 + r5;
+                    r11 = r9 & 65535;
+                    r6 = r5 - r11;
+                    r8 = r8 >>> 16;
+                    r9 = r9 >>> 16;
+                    r5 = r6 >> 16;
+                    r8 = r8 - r9;
+                    r8 = r8 + r5;
+                    r7 = r7 + 4;
+                    r5 = r8 >> 16;
+                    r6 = r6 & 65535;
+                    r8 = r8 << 16;
+                    r6 = r8 | r6;
+                    r3 = r3 + 4;
+                    r8 = ((r7 & 0xffffffffL) < (r13 & 0xffffffffL)) ? 1 : 0;
+                    r4 = r4 + 4;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r6;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d084;
+                        continue;
+                    }
+                    r7 = ((r4 & 0xffffffffL) < (r12 & 0xffffffffL)) ? 1 : 0;
+                    r9 = r3 + r0;
+                    r11 = r4 + r0;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d148;
+                        continue;
+                    }
+                case 0x5d0f0:
+                    r8 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r4 + 4;
+                    r6 = r8 & 65535;
+                    r6 = r6 + r5;
+                    r7 = r6 >> 16;
+                    r8 = r8 >>> 16;
+                    r7 = r7 + r8;
+                    r5 = r7 >> 16;
+                    r6 = r6 & 65535;
+                    r7 = r7 << 16;
+                    r6 = r7 | r6;
+                    r3 = r3 + 4;
+                    r7 = ((r4 & 0xffffffffL) < (r12 & 0xffffffffL)) ? 1 : 0;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r6;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d0f0;
+                        continue;
+                    }
+                    r3 = ~(r0 | r11);
+                    r3 = r3 + r12;
+                    r3 = r3 >>> 2;
+                    r3 = r3 + 1;
+                    r3 = r3 << 2;
+                    r3 = r9 + r3;
+                case 0x5d148:
+                    r3 = r3 + -4;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d168;
+                        continue;
+                    }
+                case 0x5d154:
+                    r3 = r3 + -4;
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r10 = r10 + -1;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d154;
+                        continue;
+                    }
+                case 0x5d168:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r10;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d18c:
+                    r2 = r16 + r0;
+                    r19 = r0 + 1;
+                    r16 = r17 + r0;
+                    r17 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5d048;
+                    continue;
+                case 0x5d1a4:
+                    r4 = r18 + r0;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d1b4;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5d1b4:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff] = r3;
+                    writePages[(r2+20)>>>12][((r2+20)>>>2)&0x3ff] = r0;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d200:
+                    pc=0x5d200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5d200() throws ExecutionException { /* 0x5d200 - 0x5d400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5d200:
+                    r2 = f13;
+                    r4 = 32752 << 16;
+                    r2 = r2 & r4;
+                    r3 = 64704 << 16;
+                    r4 = r2 + r3;
+                    if(r4 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d234;
+                        continue;
+                    }
+                    r3 = r0 + r0;
+                    f0 = r3;
+                    r2 = r4 + r0;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d234:
+                    r4 = r0 - r4;
+                    r4 = r4 >> 20;
+                    r2 = r4 < 20 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d290;
+                        continue;
+                    }
+                    r5 = r4 < 51 ? 1 : 0;
+                    r2 = r0 + r0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d280;
+                        continue;
+                    }
+                    r5 = r0 + 51;
+                    r4 = r5 - r4;
+                    r5 = r0 + 1;
+                    r4 = r5 << (r4&0x1f);
+                    r3 = r4 + r0;
+                case 0x5d26c:
+                    f0 = r3;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d280:
+                    r4 = r0 + 1;
+                    r3 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5d26c;
+                    continue;
+                case 0x5d290:
+                    r3 = r0 + r0;
+                    r5 = 8 << 16;
+                    f0 = r3;
+                    r2 = r5 >> (r4&0x1f);
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d400:
+                    pc=0x5d400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5d400() throws ExecutionException { /* 0x5d400 - 0x5d600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5d400:
+                    r29 = r29 + -40;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    r16 = r16 << 2;
+                    r18 = r4 + 20;
+                    r16 = r18 + r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r17 = readPages[(r16+-4)>>>12][((r16+-4)>>>2)&0x3ff];
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    r4 = r17 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    r20 = r5 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d440;
+                    pc=0x5c000;
+                    run_5c000(); return;
+                case 0x5d440:
+                    r3 = r0 + 32;
+                    r3 = r3 - r2;
+                    writePages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff] = r3;
+                    r3 = r2 < 11 ? 1 : 0;
+                    r19 = r16 + -4;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d4c0;
+                        continue;
+                    }
+                    r3 = r0 + 11;
+                    r3 = r3 - r2;
+                    r5 = r17 >>> (r3&0x1f);
+                    r4 = 16368 << 16;
+                    r18 = ((r18 & 0xffffffffL) < (r19 & 0xffffffffL)) ? 1 : 0;
+                    r6 = r5 | r4;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d544;
+                        continue;
+                    }
+                    r4 = readPages[(r16+-8)>>>12][((r16+-8)>>>2)&0x3ff];
+                    r3 = r4 >>> (r3&0x1f);
+                case 0x5d488:
+                    r2 = r2 + 21;
+                    r17 = r17 << (r2&0x1f);
+                    r7 = r3 | r17;
+                case 0x5d494:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    f0 = r7;
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    f1 = r6;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d4c0:
+                    r3 = ((r18 & 0xffffffffL) < (r19 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d51c;
+                        continue;
+                    }
+                    r3 = r2 + -11;
+                    r4 = r0 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d530;
+                        continue;
+                    }
+                case 0x5d4dc:
+                    r5 = r0 + 43;
+                    r2 = r5 - r2;
+                    r17 = r17 << (r3&0x1f);
+                    r5 = 16368 << 16;
+                    r17 = r17 | r5;
+                    r18 = ((r18 & 0xffffffffL) < (r19 & 0xffffffffL)) ? 1 : 0;
+                    r5 = r4 >>> (r2&0x1f);
+                    r6 = r17 | r5;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d550;
+                        continue;
+                    }
+                    r5 = readPages[(r19+-4)>>>12][((r19+-4)>>>2)&0x3ff];
+                    r3 = r4 << (r3&0x1f);
+                    r2 = r5 >>> (r2&0x1f);
+                    r7 = r2 | r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x5d494;
+                    continue;
+                case 0x5d51c:
+                    r3 = r2 + -11;
+                    r19 = r16 + -8;
+                    r4 = readPages[(r16+-8)>>>12][((r16+-8)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d4dc;
+                        continue;
+                    }
+                case 0x5d530:
+                    r2 = 16368 << 16;
+                    r6 = r17 | r2;
+                    r7 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5d494;
+                    continue;
+                case 0x5d544:
+                    r3 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5d488;
+                    continue;
+                case 0x5d550:
+                    r2 = r0 + r0;
+                    r3 = r4 << (r3&0x1f);
+                    r7 = r2 | r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x5d494;
+                    continue;
+                case 0x5d600:
+                    pc=0x5d600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5d600() throws ExecutionException { /* 0x5d600 - 0x5d800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5d600:
+                    r29 = r29 + -48;
+                    r5 = r0 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    r16 = r6 + r0;
+                    r17 = r7 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d62c;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x5d62c:
+                    r18 = r2 + r0;
+                    r19 = r16 << 1;
+                    r2 = 15 << 16;
+                    r2 = r2 | 65535;
+                    r19 = r19 >>> 21;
+                    r2 = r2 & r16;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d654;
+                        continue;
+                    }
+                    r3 = 16 << 16;
+                    r2 = r2 | r3;
+                case 0x5d654:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d6f4;
+                        continue;
+                    }
+                    r4 = r29 + 20;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d670;
+                    pc=0x5c200;
+                    run_5c200(); return;
+                case 0x5d670:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d764;
+                        continue;
+                    }
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    writePages[(r18+20)>>>12][((r18+20)>>>2)&0x3ff] = r3;
+                case 0x5d684:
+                    writePages[(r18+24)>>>12][((r18+24)>>>2)&0x3ff] = r16;
+                    r3 = r0 + 2;
+                    r16 = (r16&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r16 = r3 - r16;
+                    writePages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff] = r16;
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d720;
+                        continue;
+                    }
+                case 0x5d6a0:
+                    r3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r2 = r2 + -1074;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = r16 << 2;
+                    r2 = r18 + r2;
+                    r4 = readPages[(r2+16)>>>12][((r2+16)>>>2)&0x3ff];
+                    r16 = r16 << 5;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d6c4;
+                    pc=0x5c000;
+                    run_5c000(); return;
+                case 0x5d6c4:
+                    r3 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r16 - r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r18 + r0;
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d6f4:
+                    r4 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d700;
+                    pc=0x5c200;
+                    run_5c200(); return;
+                case 0x5d700:
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r2 + 32;
+                    writePages[(r18+20)>>>12][((r18+20)>>>2)&0x3ff] = r3;
+                    r3 = r0 + 1;
+                    writePages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff] = r3;
+                    r16 = r0 + 1;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d6a0;
+                        continue;
+                    }
+                case 0x5d720:
+                    r3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r19 = r19 + -1075;
+                    r19 = r19 + r2;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r19;
+                    r3 = r0 + 53;
+                    r2 = r3 - r2;
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r3 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r18 + r0;
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d764:
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r3 = r0 - r2;
+                    r4 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r3 = r16 << (r3&0x1f);
+                    r3 = r3 | r4;
+                    r16 = r16 >>> (r2&0x1f);
+                    writePages[(r18+20)>>>12][((r18+20)>>>2)&0x3ff] = r3;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    pc=0x5d684;
+                    continue;
+                case 0x5d800:
+                    pc=0x5d800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5d800() throws ExecutionException { /* 0x5d800 - 0x5da00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5d800:
+                    r29 = r29 + -56;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    r18 = r5 + r0;
+                    r5 = r29 + 20;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    r19 = r4 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f20;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f21;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d834;
+                    pc=0x5d400;
+                    run_5d400(); return;
+                case 0x5d834:
+                    r4 = r18 + r0;
+                    r5 = r29 + 16;
+                    f20 = f0;
+                    f21 = f1;
+                    r17 = f0;
+                    r16 = f1;
+                    /* Next insn is delay slot */ 
+                    r31=0x5d850;
+                    pc=0x5d400;
+                    run_5d400(); return;
+                case 0x5d850:
+                    r5 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r6 = readPages[(r19+16)>>>12][((r19+16)>>>2)&0x3ff];
+                    r4 = r5 - r4;
+                    r5 = readPages[(r18+16)>>>12][((r18+16)>>>2)&0x3ff];
+                    r3 = f0;
+                    r5 = r6 - r5;
+                    r5 = r5 << 5;
+                    r4 = r4 + r5;
+                    r2 = f1;
+                    if(r4 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5d8c0;
+                        continue;
+                    }
+                    r4 = r4 << 20;
+                    f20 = r17;
+                    r16 = r4 + r16;
+                    f21 = r16;
+                case 0x5d894:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    f20 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f21 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5d8c0:
+                    r4 = r4 << 20;
+                    f0 = r3;
+                    r2 = r2 - r4;
+                    f1 = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x5d894;
+                    continue;
+                case 0x5da00:
+                    pc=0x5da00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5da00() throws ExecutionException { /* 0x5da00 - 0x5dc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5da00:
+                    r2 = r4 < 24 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5da34;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-30964)>>>12][((r28+-30964)>>>2)&0x3ff];
+                    f2 = readPages[(r28+-30956)>>>12][((r28+-30956)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-30968)>>>12][((r28+-30968)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-30960)>>>12][((r28+-30960)>>>2)&0x3ff];
+                case 0x5da1c:
+                    r4 = r4 + -1;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5da1c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5da34:
+                    r2 = 7 << 16;
+                    r2 = r2 + 2176;
+                    r4 = r4 << 3;
+                    r4 = r4 + r2;
+                    f0 = readPages[(r4+4)>>>12][((r4+4)>>>2)&0x3ff];
+                    f1 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5dc00:
+                    pc=0x5dc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5dc00() throws ExecutionException { /* 0x5dc00 - 0x5de00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5dc00:
+                    r7 = readPages[(r6+16)>>>12][((r6+16)>>>2)&0x3ff];
+                    r5 = r5 + -1;
+                    r2 = r6 + 20;
+                    r8 = r5 >> 5;
+                    r7 = r7 << 2;
+                    r8 = r8 + 1;
+                    r7 = r2 + r7;
+                    r8 = r8 << 2;
+                    r3 = ((r2 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    r8 = r4 + r8;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5dc7c;
+                        continue;
+                    }
+                    r3 = r4 + r0;
+                case 0x5dc34:
+                    r2 = r2 + 4;
+                    r5 = readPages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r5;
+                    r5 = ((r2 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5dc34;
+                        continue;
+                    }
+                    r2 = r7 - r6;
+                    r2 = r2 + -21;
+                    r2 = r2 >>> 2;
+                    r2 = r2 + 1;
+                    r2 = r2 << 2;
+                    r4 = r4 + r2;
+                    r2 = ((r4 & 0xffffffffL) < (r8 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5dc88;
+                        continue;
+                    }
+                case 0x5dc74:
+                    r4 = r4 + 4;
+                    writePages[(r4+-4)>>>12][((r4+-4)>>>2)&0x3ff] = r0;
+                case 0x5dc7c:
+                    r2 = ((r4 & 0xffffffffL) < (r8 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5dc74;
+                        continue;
+                    }
+                case 0x5dc88:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5de00:
+                    pc=0x5de00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5de00() throws ExecutionException { /* 0x5de00 - 0x5e000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5de00:
+                    r3 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r2 = r5 >> 5;
+                    r6 = r4 + 20;
+                    r4 = r3 < r2 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5de74;
+                        continue;
+                    }
+                    r3 = r3 << 2;
+                    r3 = r6 + r3;
+                case 0x5de20:
+                    r2 = ((r6 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5de68;
+                        continue;
+                    }
+                    r2 = r3 + -4;
+                    r3 = readPages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5de5c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5deac;
+                    continue;
+                case 0x5de48:
+                    r2 = r2 + -4;
+                    r3 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5deac;
+                        continue;
+                    }
+                case 0x5de5c:
+                    r3 = ((r6 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5de48;
+                        continue;
+                    }
+                case 0x5de68:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5de74:
+                    r3 = r2 < r3 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5deb8;
+                        continue;
+                    }
+                    r2 = r2 << 2;
+                    r5 = r5 & 31;
+                    r3 = r6 + r2;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5de20;
+                        continue;
+                    }
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r2 >>> (r5&0x1f);
+                    r5 = r4 << (r5&0x1f);
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5de20;
+                        continue;
+                    }
+                case 0x5deac:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5deb8:
+                    r2 = r2 << 2;
+                    r3 = r6 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x5de20;
+                    continue;
+                case 0x5e000:
+                    pc=0x5e000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5e000() throws ExecutionException { /* 0x5e000 - 0x5e200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5e000:
+                    r2 = readPages[(r4+732)>>>12][((r4+732)>>>2)&0x3ff];
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e034;
+                        continue;
+                    }
+                case 0x5e01c:
+                    r2 = r0 + r0;
+                case 0x5e020:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e034:
+                    r5 = r0 + 128;
+                    /* Next insn is delay slot */ 
+                    r31=0x5e040;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x5e040:
+                    writePages[(r16+732)>>>12][((r16+732)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e080;
+                        continue;
+                    }
+                    r3 = r0 + r0;
+                    r4 = r0 + 128;
+                    /* Next insn is delay slot */ 
+                    pc=0x5e064;
+                    continue;
+                case 0x5e05c:
+                    r2 = readPages[(r16+732)>>>12][((r16+732)>>>2)&0x3ff];
+                case 0x5e064:
+                    r2 = r2 + r3;
+                    r3 = r3 + 4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    if(r3 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e05c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5e01c;
+                    continue;
+                case 0x5e080:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5e020;
+                    continue;
+                case 0x5e200:
+                    pc=0x5e200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5e200() throws ExecutionException { /* 0x5e200 - 0x5e400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5e200:
+                    r29 = r29 + -32;
+                    r2 = (r5&0xffffffffL) < (32&0xffffffffL) ? 1 : 0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e250;
+                        continue;
+                    }
+                    r2 = readPages[(r4+732)>>>12][((r4+732)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e270;
+                        continue;
+                    }
+                case 0x5e22c:
+                    r5 = r5 << 2;
+                    r5 = r2 + r5;
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    writePages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff] = r6;
+                case 0x5e23c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e250:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r0 + 22;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e270:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x5e280;
+                    pc=0x5e000;
+                    run_5e000(); return;
+                case 0x5e280:
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r6 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e29c;
+                        continue;
+                    }
+                    r2 = readPages[(r16+732)>>>12][((r16+732)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x5e22c;
+                    continue;
+                case 0x5e29c:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5e23c;
+                    continue;
+                case 0x5e400:
+                    pc=0x5e400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5e400() throws ExecutionException { /* 0x5e400 - 0x5e600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5e400:
+                    r29 = r29 + -32;
+                    r2 = (r5&0xffffffffL) < (32&0xffffffffL) ? 1 : 0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    r16 = r5 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e4f0;
+                        continue;
+                    }
+                    r2 = readPages[(r4+732)>>>12][((r4+732)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e4c0;
+                        continue;
+                    }
+                    r3 = r5 << 2;
+                    r3 = r2 + r3;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e4c0;
+                        continue;
+                    }
+                    r4 = r0 + 1;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e4b4;
+                        continue;
+                    }
+                    r4 = r0 + -1;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e490;
+                        continue;
+                    }
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r0;
+                    r4 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x5e474;
+                    return;
+                case 0x5e474:
+                    r2 = r0 + r0;
+                case 0x5e478:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e490:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r0 + 22;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r2;
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e4b4:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5e478;
+                    continue;
+                case 0x5e4c0:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5e4cc;
+                    pc=0x48a20;
+                    run_48a00(); return;
+                case 0x5e4cc:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r6 = r16 + r0;
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r5 = r2 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x489e0;
+                    run_48800(); return;
+                case 0x5e4f0:
+                    r2 = r0 + 22;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5e478;
+                    continue;
+                case 0x5e600:
+                    pc=0x5e600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5e600() throws ExecutionException { /* 0x5e600 - 0x5e800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5e600:
+                    r2 = (r5&0xffffffffL) < (32&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e6e0;
+                        continue;
+                    }
+                    r2 = readPages[(r4+732)>>>12][((r4+732)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e6bc;
+                        continue;
+                    }
+                case 0x5e628:
+                    r3 = r5 << 2;
+                    r3 = r2 + r3;
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e6b0;
+                        continue;
+                    }
+                    r4 = r0 + -1;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e698;
+                        continue;
+                    }
+                    r4 = r0 + 1;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e680;
+                        continue;
+                    }
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r0;
+                    r4 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    r31=0x5e668;
+                    return;
+                case 0x5e668:
+                    r2 = r0 + r0;
+                case 0x5e66c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e680:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r0 + 3;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e698:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r0 + 2;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e6b0:
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5e66c;
+                    continue;
+                case 0x5e6bc:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x5e6c8;
+                    pc=0x5e000;
+                    run_5e000(); return;
+                case 0x5e6c8:
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5e6ec;
+                        continue;
+                    }
+                    r2 = readPages[(r16+732)>>>12][((r16+732)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x5e628;
+                    continue;
+                case 0x5e6e0:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5e6ec:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5e66c;
+                    continue;
+                case 0x5e800:
+                    pc=0x5e800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5e800() throws ExecutionException { /* 0x5e800 - 0x5ea00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5e800:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x5e400;
+                    run_5e400(); return;
+                case 0x5ea00:
+                    pc=0x5ea00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5ea00() throws ExecutionException { /* 0x5ea00 - 0x5ec00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5ea00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5e200;
+                    run_5e200(); return;
+                case 0x5ec00:
+                    pc=0x5ec00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5ec00() throws ExecutionException { /* 0x5ec00 - 0x5ee00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5ec00:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x5e000;
+                    run_5e000(); return;
+                case 0x5ee00:
+                    pc=0x5ee00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5ee00() throws ExecutionException { /* 0x5ee00 - 0x5f000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5ee00:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x5e600;
+                    run_5e600(); return;
+                case 0x5f000:
+                    pc=0x5f000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5f000() throws ExecutionException { /* 0x5f000 - 0x5f200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5f000:
+                    r29 = r29 + -136;
+                    r3 = r0 + 516;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r16;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r6;
+                    r16 = r5 + r0;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r7;
+                    addr=r29+28;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    r31=0x5f030;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x5f030:
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r2 = 4 << 16;
+                    r2 = r2 + 9216;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r2;
+                    r7 = r29 + 144;
+                    r2 = r0 + -1;
+                    r5 = r29 + 16;
+                    r6 = r16 + r0;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r0;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r0;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x5f070;
+                    pc=0x61400;
+                    run_61400(); return;
+                case 0x5f070:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r16 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f200:
+                    pc=0x5f200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5f200() throws ExecutionException { /* 0x5f200 - 0x5f400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5f200:
+                    r29 = r29 + -144;
+                    r2 = r0 + 516;
+                    writePages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    r4 = r5 + r0;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r31;
+                    writePages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff] = r7;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r5;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r6;
+                    addr=r29+28;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x5f234;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x5f234:
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r2 = 4 << 16;
+                    r2 = r2 + 9216;
+                    r6 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r2;
+                    r7 = r29 + 156;
+                    r2 = r0 + -1;
+                    r4 = r16 + r0;
+                    r5 = r29 + 16;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r0;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r0;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x5f274;
+                    pc=0x61400;
+                    run_61400(); return;
+                case 0x5f274:
+                    r31 = readPages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff];
+                    r16 = readPages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff];
+                    r29 = r29 + 144;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f400:
+                    pc=0x5f400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5f400() throws ExecutionException { /* 0x5f400 - 0x5f600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5f400:
+                    r2 = r4 + r0;
+                    r3 = r4 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f434;
+                    continue;
+                case 0x5f410:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5cc;
+                        continue;
+                    }
+                    r5 = r5 + 1;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r7 = tmp;
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r7&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r6 = r6 + -1;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5d4;
+                        continue;
+                    }
+                case 0x5f434:
+                    r7 = r5 & 3;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f410;
+                        continue;
+                    }
+                    r4 = (r6&0xffffffffL) < (4&0xffffffffL) ? 1 : 0;
+                    r12 = r6 + r0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5f8;
+                        continue;
+                    }
+                    r6 = r6 & 3;
+                    r12 = r12 - r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f494;
+                    continue;
+                case 0x5f460:
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r9&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f4c0;
+                        continue;
+                    }
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r10&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r10 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f4c8;
+                        continue;
+                    }
+                    addr=r3+3;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r11&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r11 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f4d0;
+                        continue;
+                    }
+                    r3 = r3 + 4;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5f8;
+                        continue;
+                    }
+                    r12 = r7 + r0;
+                case 0x5f494:
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    addr=r5+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r9 = tmp;
+                    addr=r5+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r10 = tmp;
+                    addr=r5+3;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r11 = tmp;
+                    r7 = r12 + -4;
+                    r5 = r5 + 4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r8&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f460;
+                        continue;
+                    }
+                    r7 = r12 + -3;
+                    r3 = r3 + -1;
+                case 0x5f4c0:
+                    r7 = r7 + 1;
+                    r3 = r3 + -1;
+                case 0x5f4c8:
+                    r7 = r7 + 1;
+                    r3 = r3 + -1;
+                case 0x5f4d0:
+                    r6 = r7 + r6;
+                    r3 = r3 + 4;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5c4;
+                        continue;
+                    }
+                    r4 = r3 & 3;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f500;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x5f51c;
+                    continue;
+                case 0x5f4f4:
+                    r5 = r3 & 3;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f51c;
+                        continue;
+                    }
+                case 0x5f500:
+                    r3 = r3 + 1;
+                    r6 = r6 + -1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f4f4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f51c:
+                    r4 = (r6&0xffffffffL) < (16&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f668;
+                        run_5f600(); return;
+                    }
+                    r5 = r3 + r0;
+                    r7 = r6 + r0;
+                case 0x5f530:
+                    r7 = r7 + -16;
+                    r5 = r5 + 16;
+                    r8 = (r7&0xffffffffL) < (16&0xffffffffL) ? 1 : 0;
+                    writePages[(r5+-16)>>>12][((r5+-16)>>>2)&0x3ff] = r0;
+                    writePages[(r5+-12)>>>12][((r5+-12)>>>2)&0x3ff] = r0;
+                    writePages[(r5+-8)>>>12][((r5+-8)>>>2)&0x3ff] = r0;
+                    writePages[(r5+-4)>>>12][((r5+-4)>>>2)&0x3ff] = r0;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f530;
+                        continue;
+                    }
+                    r5 = r6 + -16;
+                    r5 = r5 >>> 4;
+                    r5 = r5 + 1;
+                    r5 = r5 << 4;
+                    r4 = r6 & 15;
+                    r3 = r3 + r5;
+                case 0x5f56c:
+                    r5 = (r4&0xffffffffL) < (8&0xffffffffL) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f588;
+                        continue;
+                    }
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r0;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r0;
+                    r4 = r4 + -8;
+                    r3 = r3 + 8;
+                case 0x5f588:
+                    r5 = (r4&0xffffffffL) < (4&0xffffffffL) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5a0;
+                        continue;
+                    }
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r0;
+                    r4 = r4 + -4;
+                    r3 = r3 + 4;
+                case 0x5f5a0:
+                    r5 = (r4&0xffffffffL) < (2&0xffffffffL) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5b8;
+                        continue;
+                    }
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r0&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = r4 + -2;
+                    r3 = r3 + 2;
+                case 0x5f5b8:
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5c4;
+                        continue;
+                    }
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x5f5c4:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f5cc:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f5d4:
+                    r6 = r3 + r6;
+                    if(r3 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5c4;
+                        continue;
+                    }
+                case 0x5f5e0:
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r3 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5e0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f5f8:
+                    r6 = r3 + r6;
+                    if(r3 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5c4;
+                        continue;
+                    }
+                case 0x5f600:
+                    pc=0x5f600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5f600() throws ExecutionException { /* 0x5f600 - 0x5f800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5f600:
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r8 = r5 + 1;
+                    r7 = r3 + 1;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r8 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f640;
+                        continue;
+                    }
+                case 0x5f620:
+                    if(r7 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f660;
+                        continue;
+                    }
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r7 = r7 + 1;
+                    addr=r7+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r3 + 1;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f620;
+                        continue;
+                    }
+                case 0x5f640:
+                    if(r6 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f5c4;
+                        run_5f400(); return;
+                    }
+                case 0x5f648:
+                    r7 = r7 + 1;
+                    addr=r7+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r7 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f648;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f660:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f668:
+                    r4 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f56c;
+                    run_5f400(); return;
+                case 0x5f800:
+                    pc=0x5f800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5f800() throws ExecutionException { /* 0x5f800 - 0x5fa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5f800:
+                    r12 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r2 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f814;
+                    continue;
+                case 0x5f810:
+                    r2 = r3 + r0;
+                case 0x5f814:
+                    r3 = r2 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r9 = r12 + r8;
+                    addr=r9+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r9 = tmp;
+                    r9 = r9 & 8;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f810;
+                        continue;
+                    }
+                    r9 = r0 + 45;
+                    if(r8 == r9) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f9cc;
+                        continue;
+                    }
+                    r9 = r0 + 43;
+                    if(r8 == r9) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f9e0;
+                        continue;
+                    }
+                    r25 = r0 + r0;
+                case 0x5f854:
+                    r2 = r0 + -17;
+                    r2 = r7 & r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f97c;
+                        continue;
+                    }
+                    r24 = r0 + -1;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r7!=0) {
+                        hi = (int)((r24 & 0xffffffffL) % (r7 & 0xffffffffL)); lo = (int)((r24 & 0xffffffffL) / (r7 & 0xffffffffL));
+                        }
+                        pc=0x5f874;
+                        continue;
+                    }
+                    if(r7!=0) {
+                    hi = (int)((r24 & 0xffffffffL) % (r7 & 0xffffffffL)); lo = (int)((r24 & 0xffffffffL) / (r7 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x5f874:
+                    r15 = r7 + r0;
+                    r24 = hi;
+                    r13 = lo;
+                case 0x5f880:
+                    r10 = r0 + r0;
+                    r2 = r0 + r0;
+                    r14 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f8dc;
+                    continue;
+                case 0x5f894:
+                    r8 = r8 + -48;
+                    r9 = r8 < r7 ? 1 : 0;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f91c;
+                        continue;
+                    }
+                case 0x5f8a4:
+                    if(r10 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f958;
+                        continue;
+                    }
+                    r9 = ((r13 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f958;
+                        continue;
+                    }
+                    if(r2 == r13) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f94c;
+                        continue;
+                    }
+                case 0x5f8c0:
+                    { long hilo = (long)(r2) * ((long)r15); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r10 = r0 + 1;
+                    r2 = lo;
+                    r2 = r8 + r2;
+                case 0x5f8d0:
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                case 0x5f8dc:
+                    r9 = r12 + r8;
+                    addr=r9+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r9 = tmp;
+                    r11 = r9 & 4;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f894;
+                        continue;
+                    }
+                    r9 = r9 & 3;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f91c;
+                        continue;
+                    }
+                    if(r9 == r14) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f964;
+                        continue;
+                    }
+                    r9 = r0 + 87;
+                    r8 = r8 - r9;
+                case 0x5f910:
+                    r9 = r8 < r7 ? 1 : 0;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f8a4;
+                        continue;
+                    }
+                case 0x5f91c:
+                    if(r10 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f9b8;
+                        continue;
+                    }
+                    if(r25 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f9ac;
+                        continue;
+                    }
+                case 0x5f92c:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f974;
+                        continue;
+                    }
+                    if(r10 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f940;
+                        continue;
+                    }
+                    r5 = r3 + -1;
+                case 0x5f940:
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f94c:
+                    r9 = r24 < r8 ? 1 : 0;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f8c0;
+                        continue;
+                    }
+                case 0x5f958:
+                    r10 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f8d0;
+                    continue;
+                case 0x5f964:
+                    r9 = r0 + 55;
+                    r8 = r8 - r9;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f910;
+                    continue;
+                case 0x5f974:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x5f97c:
+                    r2 = r0 + 48;
+                    if(r8 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5f9f4;
+                        continue;
+                    }
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5fa50;
+                        run_5fa00(); return;
+                    }
+                    r13 = 6553 << 16;
+                    r24 = r0 + 5;
+                    r13 = r13 | 39321;
+                    r15 = r0 + 10;
+                    r7 = r0 + 10;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f880;
+                    continue;
+                case 0x5f9ac:
+                    r2 = r0 - r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f92c;
+                    continue;
+                case 0x5f9b8:
+                    r2 = r0 + 34;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f92c;
+                    continue;
+                case 0x5f9cc:
+                    r3 = r2 + 2;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r25 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f854;
+                    continue;
+                case 0x5f9e0:
+                    r3 = r2 + 2;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r25 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f854;
+                    continue;
+                case 0x5f9f4:
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r9 = tmp;
+                    r2 = r0 + 88;
+                    r9 = r9 & 223;
+                case 0x5fa00:
+                    pc=0x5fa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5fa00() throws ExecutionException { /* 0x5fa00 - 0x5fc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5fa00:
+                    if(r9 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5fa2c;
+                        continue;
+                    }
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5fa50;
+                        continue;
+                    }
+                    r13 = 8191 << 16;
+                    r24 = r0 + 7;
+                    r13 = r13 | 65535;
+                    r15 = r0 + 8;
+                    r7 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f880;
+                    run_5f800(); return;
+                case 0x5fa2c:
+                    r13 = 4095 << 16;
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r24 = r0 + 15;
+                    r3 = r3 + 2;
+                    r13 = r13 | 65535;
+                    r15 = r0 + 16;
+                    r7 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f880;
+                    run_5f800(); return;
+                case 0x5fa50:
+                    r13 = r0 + -1;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r7!=0) {
+                        hi = (int)((r13 & 0xffffffffL) % (r7 & 0xffffffffL)); lo = (int)((r13 & 0xffffffffL) / (r7 & 0xffffffffL));
+                        }
+                        pc=0x5fa60;
+                        continue;
+                    }
+                    if(r7!=0) {
+                    hi = (int)((r13 & 0xffffffffL) % (r7 & 0xffffffffL)); lo = (int)((r13 & 0xffffffffL) / (r7 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x5fa60:
+                    r15 = r7 + r0;
+                    r24 = hi;
+                    r13 = lo;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f880;
+                    run_5f800(); return;
+                case 0x5fc00:
+                    pc=0x5fc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5fc00() throws ExecutionException { /* 0x5fc00 - 0x5fe00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5fc00:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5f800;
+                    run_5f800(); return;
+                case 0x5fe00:
+                    pc=0x5fe00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_5fe00() throws ExecutionException { /* 0x5fe00 - 0x60000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x5fe00:
+                    r2 = readPages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff];
+                    r29 = r29 + -56;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r23;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r30;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r21;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r23 = r6 + r0;
+                    r18 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5fffc;
+                        continue;
+                    }
+                    r20 = r4 + r0;
+                    r3 = readPages[(r5+8)>>>12][((r5+8)>>>2)&0x3ff];
+                    r4 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r17 = r5 + r0;
+                    r30 = r0 + r0;
+                    r16 = r0 + r0;
+                case 0x5fe58:
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5fec4;
+                        continue;
+                    }
+                    r2 = ((r16 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    r19 = r3 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5fed8;
+                        continue;
+                    }
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r2 & 1152;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5fee8;
+                        continue;
+                    }
+                    r22 = r19 + r0;
+                case 0x5fe88:
+                    r5 = r30 + r0;
+                    r6 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5fe98;
+                    pc=0x5b600;
+                    run_5b600(); return;
+                case 0x5fe98:
+                    r3 = readPages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff];
+                    r4 = readPages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff];
+                    r2 = readPages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff];
+                    r3 = r3 - r19;
+                    r4 = r4 + r22;
+                    r2 = r2 - r16;
+                    writePages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff] = r3;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r4;
+                    writePages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5fffc;
+                        continue;
+                    }
+                case 0x5fec4:
+                    r30 = readPages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff];
+                    r16 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    r18 = r18 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x5fe58;
+                    continue;
+                case 0x5fed8:
+                    r19 = r16 + r0;
+                    r22 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5fe88;
+                    continue;
+                case 0x5fee8:
+                    r5 = readPages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff];
+                    r6 = r16 + 1;
+                    r21 = r4 - r5;
+                    r4 = readPages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff];
+                    r6 = r6 + r21;
+                    r22 = r4 << 1;
+                    r4 = r22 + r4;
+                    r22 = r4 >>> 31;
+                    r22 = r22 + r4;
+                    r22 = r22 >> 1;
+                    r4 = ((r22 & 0xffffffffL) < (r6 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ff98;
+                        continue;
+                    }
+                    r2 = r2 & 1024;
+                    r22 = r6 + r0;
+                    r4 = r20 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ffac;
+                        continue;
+                    }
+                case 0x5ff30:
+                    r5 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5ff3c;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x5ff3c:
+                    r19 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ffd0;
+                        continue;
+                    }
+                    r5 = readPages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5ff5c;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x5ff5c:
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r3 = r0 + -1153;
+                    r2 = r2 & r3;
+                    r2 = r2 | 128;
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x5ff70:
+                    r4 = r19 + r21;
+                    writePages[(r17+20)>>>12][((r17+20)>>>2)&0x3ff] = r22;
+                    r22 = r22 - r21;
+                    writePages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff] = r19;
+                    writePages[(r17+8)>>>12][((r17+8)>>>2)&0x3ff] = r22;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r4;
+                    r19 = r16 + r0;
+                    r22 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x5fe88;
+                    continue;
+                case 0x5ff98:
+                    r2 = r2 & 1024;
+                    r6 = r22 + r0;
+                    r4 = r20 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ff30;
+                        continue;
+                    }
+                case 0x5ffac:
+                    /* Next insn is delay slot */ 
+                    r31=0x5ffb4;
+                    pc=0x40800;
+                    run_40800(); return;
+                case 0x5ffb4:
+                    r19 = r2 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x5ff70;
+                        continue;
+                    }
+                    r5 = readPages[(r17+16)>>>12][((r17+16)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x5ffd0;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x5ffd0:
+                    r2 = r0 + 12;
+                    writePages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff] = r2;
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 64;
+                    addr=r17+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r23+8)>>>12][((r23+8)>>>2)&0x3ff] = r0;
+                    writePages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff] = r0;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x60000;
+                    run_60000(); return;
+                case 0x5fffc:
+                    writePages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff] = r0;
+                case 0x60000:
+                    pc=0x60000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_60000() throws ExecutionException { /* 0x60000 - 0x60200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x60000:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r30 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r23 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x60200:
+                    pc=0x60200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_60200() throws ExecutionException { /* 0x60200 - 0x60400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x60200:
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r29 = r29 + -224;
+                    r2 = r2 & 128;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = r17;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = r16;
+                    writePages[(r29+220)>>>12][((r29+220)>>>2)&0x3ff] = r31;
+                    writePages[(r29+216)>>>12][((r29+216)>>>2)&0x3ff] = r30;
+                    writePages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff] = r23;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = r22;
+                    writePages[(r29+204)>>>12][((r29+204)>>>2)&0x3ff] = r21;
+                    writePages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff] = r20;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = r19;
+                    writePages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff] = r18;
+                    writePages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff] = r4;
+                    r16 = r5 + r0;
+                    r17 = r6 + r0;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r7;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6025c;
+                        continue;
+                    }
+                    r2 = readPages[(r5+16)>>>12][((r5+16)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x611e4;
+                        run_61000(); return;
+                    }
+                case 0x6025c:
+                    r5 = r29 + 119;
+                    r21 = r29 + 120;
+                    r4 = r29 + 16;
+                    r2 = 7 << 16;
+                    r6 = r21 - r5;
+                    r18 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r4;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r0;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r0;
+                    writePages[(r29+168)>>>12][((r29+168)>>>2)&0x3ff] = r0;
+                    writePages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff] = r0;
+                    r3 = r4 + r0;
+                    r22 = r2 + 2748;
+                    writePages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff] = r5;
+                    writePages[(r29+172)>>>12][((r29+172)>>>2)&0x3ff] = r6;
+                case 0x60298:
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60c98;
+                        run_60c00(); return;
+                    }
+                case 0x602a8:
+                    r4 = r0 + 37;
+                    r19 = r17 + r0;
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x602c8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x60328;
+                    continue;
+                case 0x602c0:
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x602dc;
+                        continue;
+                    }
+                case 0x602c8:
+                    r19 = r19 + 1;
+                    addr=r19+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x602c0;
+                        continue;
+                    }
+                case 0x602dc:
+                    r20 = r19 - r17;
+                    if(r20 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60328;
+                        continue;
+                    }
+                    r2 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r17;
+                    r2 = r2 + r20;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r20;
+                    r2 = r2 + 1;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    r2 = r2 < 8 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60edc;
+                        run_60e00(); return;
+                    }
+                    r3 = r3 + 8;
+                case 0x60318:
+                    r2 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    r2 = r2 + r20;
+                    writePages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff] = r2;
+                case 0x60328:
+                    addr=r19+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61160;
+                        run_61000(); return;
+                    }
+                    r2 = r19 + 1;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r6 = r0 + r0;
+                    r23 = r0 + -1;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r0;
+                    r19 = r0 + r0;
+                    r7 = r0 + 42;
+                    r8 = r0 + r0;
+                case 0x60358:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r17 = r2 + 1;
+                case 0x60360:
+                    r2 = r4 + -32;
+                    r5 = (r2&0xffffffffL) < (89&0xffffffffL) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x608dc;
+                        run_60800(); return;
+                    }
+                case 0x60370:
+                    r5 = 7 << 16;
+                    r2 = r2 << 2;
+                    r5 = r5 + 2376;
+                    r2 = r5 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x60390:
+                    r19 = r19 | 16;
+                case 0x60394:
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    continue;
+                case 0x603a0:
+                    r4 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r8 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r4 + 4;
+                    if(r8 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6103c;
+                        run_61000(); return;
+                    }
+                    r8 = r0 - r8;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r2;
+                case 0x603c0:
+                    r19 = r19 | 4;
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    continue;
+                case 0x603d0:
+                    r6 = r0 + 43;
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    continue;
+                case 0x603e0:
+                    r2 = r19 & 16;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x610ac;
+                        run_61000(); return;
+                    }
+                    r19 = r19 & 64;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6118c;
+                        run_61000(); return;
+                    }
+                    r6 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                case 0x60400:
+                    pc=0x60400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_60400() throws ExecutionException { /* 0x60400 - 0x60600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x60400:
+                    r4 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r6 = r6 + 4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r4&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x60298;
+                    run_60200(); return;
+                case 0x6041c:
+                    r2 = 7 << 16;
+                    r2 = r2 + 248;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+168)>>>12][((r29+168)>>>2)&0x3ff] = r2;
+                case 0x60430:
+                    r2 = r19 & 16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60448;
+                        continue;
+                    }
+                    r2 = r19 & 64;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61090;
+                        run_61000(); return;
+                    }
+                case 0x60448:
+                    r5 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r5;
+                case 0x6045c:
+                    r5 = r19 & 1;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x609c8;
+                        run_60800(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x609c8;
+                        run_60800(); return;
+                    }
+                    r5 = r0 + 48;
+                    addr=r29+132;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+133;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = r19 | 2;
+                    r4 = r0 + 2;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r23;
+                    r5 = r0 + r0;
+                case 0x60490:
+                    if(r23 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x604a0;
+                        continue;
+                    }
+                    r6 = r0 + -129;
+                    r19 = r19 & r6;
+                case 0x604a0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60d0c;
+                        run_60c00(); return;
+                    }
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60d0c;
+                        run_60c00(); return;
+                    }
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x604c4;
+                        continue;
+                    }
+                    r2 = r19 & 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61074;
+                        run_61000(); return;
+                    }
+                case 0x604c4:
+                    r30 = r21 + r0;
+                case 0x604c8:
+                    r6 = readPages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff];
+                    r2 = r6 < r23 ? 1 : 0;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r6;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x604e4;
+                        continue;
+                    }
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r23;
+                case 0x604e4:
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6058c;
+                        continue;
+                    }
+                    r2 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x6058c;
+                    continue;
+                case 0x60504:
+                    r19 = r19 | 64;
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    run_60200(); return;
+                case 0x60514:
+                    r2 = r19 & 16;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60854;
+                        run_60800(); return;
+                    }
+                case 0x60528:
+                    r4 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r4 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r4;
+                case 0x6053c:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6087c;
+                        run_60800(); return;
+                    }
+                case 0x60544:
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r23;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x60490;
+                    continue;
+                case 0x60558:
+                    r5 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r6 = r0 + 1;
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    addr=r29+80;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 1;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r5;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r6;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r2;
+                    r30 = r29 + 80;
+                case 0x60588:
+                    r23 = r0 + r0;
+                case 0x6058c:
+                    r4 = r19 & 2;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r4;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x605ac;
+                        continue;
+                    }
+                    r5 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r5 = r5 + 2;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r5;
+                case 0x605ac:
+                    r6 = r19 & 132;
+                    writePages[(r29+160)>>>12][((r29+160)>>>2)&0x3ff] = r6;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x609d4;
+                        run_60800(); return;
+                    }
+                    r2 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r4 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r20 = r2 - r4;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x609d4;
+                        run_60800(); return;
+                    }
+                    r2 = r20 < 17 ? 1 : 0;
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61248;
+                        run_61200(); return;
+                    }
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    writePages[(r29+164)>>>12][((r29+164)>>>2)&0x3ff] = r22;
+                    r9 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x6060c;
+                    run_60600(); return;
+                case 0x605f8:
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                case 0x60600:
+                    pc=0x60600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_60600() throws ExecutionException { /* 0x60600 - 0x60800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x60600:
+                    r3 = r3 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60670;
+                        continue;
+                    }
+                case 0x6060c:
+                    r2 = r2 + 1;
+                    r5 = r5 + 16;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r22;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r9;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x605f8;
+                        run_60400(); return;
+                    }
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    writePages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff] = r9;
+                    /* Next insn is delay slot */ 
+                    r31=0x60648;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60648:
+                    r9 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6060c;
+                        continue;
+                    }
+                case 0x60670:
+                    r2 = r2 + 1;
+                    r6 = readPages[(r29+164)>>>12][((r29+164)>>>2)&0x3ff];
+                    r5 = r20 + r5;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r6;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60fe0;
+                        run_60e00(); return;
+                    }
+                    r3 = r3 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x609dc;
+                    run_60800(); return;
+                case 0x606a4:
+                    r19 = r19 | 16;
+                    r2 = r19 & 16;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x607a0;
+                        continue;
+                    }
+                case 0x606b8:
+                    r4 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r4 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r4;
+                    r4 = r0 + 1;
+                case 0x606d0:
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r23;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60490;
+                    run_60400(); return;
+                case 0x606e4:
+                    r2 = 7 << 16;
+                    r2 = r2 + 228;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+168)>>>12][((r29+168)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x60430;
+                    run_60400(); return;
+                case 0x60700:
+                    r19 = r19 | 16;
+                    r2 = r19 & 16;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x609a0;
+                        run_60800(); return;
+                    }
+                case 0x60714:
+                    r4 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r4 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r4;
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x606d0;
+                    continue;
+                case 0x60734:
+                    r4 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r5 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r0 + 48;
+                    addr=r29+132;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = r0 + 120;
+                    addr=r29+133;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = 7 << 16;
+                    r4 = r4 + 248;
+                    r5 = r5 + 4;
+                    writePages[(r29+168)>>>12][((r29+168)>>>2)&0x3ff] = r4;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    r19 = r19 | 2;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r5;
+                    r4 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x606d0;
+                    continue;
+                case 0x60778:
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60394;
+                        run_60200(); return;
+                    }
+                    r6 = r0 + 32;
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    run_60200(); return;
+                case 0x60790:
+                    r2 = r19 & 16;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x606b8;
+                        continue;
+                    }
+                case 0x607a0:
+                    r2 = r19 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x610e8;
+                        run_61000(); return;
+                    }
+                    r5 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    addr=r5+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r5 = r5 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x606d0;
+                    continue;
+                case 0x607c8:
+                    r6 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    r30 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r20 = r6 + 4;
+                    if(r30 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61210;
+                        run_61200(); return;
+                    }
+                    r4 = r30 + r0;
+                    if(r23 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x611ac;
+                        run_61000(); return;
+                    }
+                    r5 = r0 + r0;
+                    r6 = r23 + r0;
+                    writePages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x60804;
+                    pc=0x5b400;
+                    run_5b400(); return;
+                case 0x60800:
+                    pc=0x60800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_60800() throws ExecutionException { /* 0x60800 - 0x60a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x60800:
+                case 0x60804:
+                    r3 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61278;
+                        run_61200(); return;
+                    }
+                    r2 = r2 - r30;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r2;
+                    r2 = r23 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60828;
+                        continue;
+                    }
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r23;
+                case 0x60828:
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r20;
+                    r23 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x6083c:
+                    r19 = r19 | 16;
+                    r2 = r19 & 16;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60528;
+                        run_60400(); return;
+                    }
+                case 0x60854:
+                    r2 = r19 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x610cc;
+                        run_61000(); return;
+                    }
+                    r5 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    addr=r5+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r5 = r5 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r5;
+                    if(r2 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60544;
+                        run_60400(); return;
+                    }
+                case 0x6087c:
+                    r4 = r0 + 45;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 - r2;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r23;
+                    r5 = r0 + 45;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x60490;
+                    run_60400(); return;
+                case 0x6089c:
+                    r8 = r0 + r0;
+                    r2 = r4 + -48;
+                case 0x608a4:
+                    r4 = r8 << 1;
+                    r17 = r17 + 1;
+                    r8 = r8 << 3;
+                    r8 = r4 + r8;
+                    addr=r17+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r8 = r8 + r2;
+                    r2 = r4 + -48;
+                    r5 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x608a4;
+                        continue;
+                    }
+                    r2 = r4 + -32;
+                    r5 = (r2&0xffffffffL) < (89&0xffffffffL) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60370;
+                        run_60200(); return;
+                    }
+                case 0x608dc:
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61160;
+                        run_61000(); return;
+                    }
+                    addr=r29+80;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 1;
+                    r4 = r0 + 1;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r2;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r4;
+                    r30 = r29 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=0x60588;
+                    run_60400(); return;
+                case 0x60910:
+                    r19 = r19 | 128;
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    run_60200(); return;
+                case 0x60920:
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r5 = r17 + 1;
+                    if(r4 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6129c;
+                        run_61200(); return;
+                    }
+                    r2 = r4 + -48;
+                    r9 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    r23 = r0 + r0;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60974;
+                        continue;
+                    }
+                case 0x60944:
+                    r4 = r23 << 1;
+                    r5 = r5 + 1;
+                    r23 = r23 << 3;
+                    r23 = r4 + r23;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r23 = r2 + r23;
+                    r2 = r4 + -48;
+                    r9 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60944;
+                        continue;
+                    }
+                    if(r23 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x611d4;
+                        run_61000(); return;
+                    }
+                case 0x60974:
+                    r17 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60360;
+                    run_60200(); return;
+                case 0x60980:
+                    r19 = r19 | 1;
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    run_60200(); return;
+                case 0x60990:
+                    r2 = r19 & 16;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60714;
+                        run_60600(); return;
+                    }
+                case 0x609a0:
+                    r2 = r19 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61104;
+                        run_61000(); return;
+                    }
+                    r5 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    addr=r5+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r5 = r5 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x606d0;
+                    run_60600(); return;
+                case 0x609c8:
+                    r4 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x606d0;
+                    run_60600(); return;
+                case 0x609d4:
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                case 0x609dc:
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60a1c;
+                        run_60a00(); return;
+                    }
+                    r4 = r29 + 134;
+                    r2 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    r4 = r0 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                case 0x60a00:
+                    pc=0x60a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_60a00() throws ExecutionException { /* 0x60a00 - 0x60c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x60a00:
+                    r5 = r5 + 1;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60f80;
+                        run_60e00(); return;
+                    }
+                    r3 = r3 + 8;
+                case 0x60a1c:
+                    r4 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60a5c;
+                        continue;
+                    }
+                    r4 = r29 + 132;
+                    r2 = r2 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    r4 = r0 + 2;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    r5 = r5 + 2;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60fb0;
+                        run_60e00(); return;
+                    }
+                    r3 = r3 + 8;
+                case 0x60a5c:
+                    r6 = readPages[(r29+160)>>>12][((r29+160)>>>2)&0x3ff];
+                    r4 = r0 + 128;
+                    if(r6 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60dac;
+                        run_60c00(); return;
+                    }
+                case 0x60a6c:
+                    r4 = readPages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff];
+                    r23 = r23 - r4;
+                    if(r23 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60b40;
+                        continue;
+                    }
+                    r4 = r23 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61150;
+                        run_61000(); return;
+                    }
+                    r4 = 7 << 16;
+                    r20 = r4 + 2732;
+                    r9 = r0 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x60ab4;
+                    continue;
+                case 0x60aa0:
+                    r23 = r23 + -16;
+                    r4 = r23 < 17 ? 1 : 0;
+                    r3 = r3 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60b18;
+                        continue;
+                    }
+                case 0x60ab4:
+                    r2 = r2 + 1;
+                    r5 = r5 + 16;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r20;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r9;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60aa0;
+                        continue;
+                    }
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    writePages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff] = r9;
+                    /* Next insn is delay slot */ 
+                    r31=0x60af0;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60af0:
+                    r9 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r23 = r23 + -16;
+                    r4 = r23 < 17 ? 1 : 0;
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60ab4;
+                        continue;
+                    }
+                case 0x60b18:
+                    r2 = r2 + 1;
+                    r5 = r5 + r23;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r20;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r23;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60f04;
+                        run_60e00(); return;
+                    }
+                    r3 = r3 + 8;
+                case 0x60b40:
+                    r6 = readPages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r5 = r6 + r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    r2 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r30;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r6;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60ea4;
+                        run_60e00(); return;
+                    }
+                    r3 = r3 + 8;
+                case 0x60b6c:
+                    r19 = r19 & 4;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60c50;
+                        run_60c00(); return;
+                    }
+                    r2 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r4 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r19 = r2 - r4;
+                    if(r19 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60c50;
+                        run_60c00(); return;
+                    }
+                    r2 = r19 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61258;
+                        run_61200(); return;
+                    }
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    writePages[(r29+164)>>>12][((r29+164)>>>2)&0x3ff] = r22;
+                    r23 = r0 + 16;
+                    r6 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60bc8;
+                    continue;
+                case 0x60bb4:
+                    r19 = r19 + -16;
+                    r4 = r19 < 17 ? 1 : 0;
+                    r3 = r3 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60c24;
+                        run_60c00(); return;
+                    }
+                case 0x60bc8:
+                    r2 = r2 + 1;
+                    r6 = r6 + 16;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r22;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r23;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r6;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60bb4;
+                        continue;
+                    }
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x60c00;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60c00:
+                    pc=0x60c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_60c00() throws ExecutionException { /* 0x60c00 - 0x60e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x60c00:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        continue;
+                    }
+                    r19 = r19 + -16;
+                    r4 = r19 < 17 ? 1 : 0;
+                    r6 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60bc8;
+                        run_60a00(); return;
+                    }
+                case 0x60c24:
+                    r5 = r6 + r0;
+                case 0x60c28:
+                    r2 = r2 + 1;
+                    r6 = readPages[(r29+164)>>>12][((r29+164)>>>2)&0x3ff];
+                    r5 = r5 + r19;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    r2 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r6;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r19;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6104c;
+                        run_61000(); return;
+                    }
+                case 0x60c50:
+                    r2 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r4 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r3 = r2 < r4 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60c6c;
+                        continue;
+                    }
+                    r2 = r4 + r0;
+                case 0x60c6c:
+                    r3 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    r3 = r3 + r2;
+                    writePages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff] = r3;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60ca4;
+                        continue;
+                    }
+                case 0x60c84:
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r0;
+                    r3 = r29 + 16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x602a8;
+                        run_60200(); return;
+                    }
+                case 0x60c98:
+                    r19 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60328;
+                    run_60200(); return;
+                case 0x60ca4:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x60cb8;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60cb8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60c84;
+                        continue;
+                    }
+                case 0x60cc0:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60ed0;
+                        run_60e00(); return;
+                    }
+                    r2 = r0 + -1;
+                case 0x60cd8:
+                    r31 = readPages[(r29+220)>>>12][((r29+220)>>>2)&0x3ff];
+                    r30 = readPages[(r29+216)>>>12][((r29+216)>>>2)&0x3ff];
+                    r23 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    r22 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    r21 = readPages[(r29+204)>>>12][((r29+204)>>>2)&0x3ff];
+                    r20 = readPages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff];
+                    r19 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                    r18 = readPages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff];
+                    r17 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    r16 = readPages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff];
+                    r29 = r29 + 224;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x60d0c:
+                    r6 = r0 + 1;
+                    if(r4 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60f34;
+                        run_60e00(); return;
+                    }
+                    r6 = r0 + 2;
+                    r30 = r21 + r0;
+                    if(r4 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60d5c;
+                        continue;
+                    }
+                    r6 = readPages[(r29+168)>>>12][((r29+168)>>>2)&0x3ff];
+                case 0x60d2c:
+                    r4 = r2 & 15;
+                    r4 = r6 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r30 = r30 + -1;
+                    r2 = r2 >>> 4;
+                    addr=r30+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60d2c;
+                        continue;
+                    }
+                    r4 = r21 - r30;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x60d5c:
+                    r4 = r2 & 7;
+                    r30 = r30 + -1;
+                    r4 = r4 + 48;
+                    r2 = r2 >>> 3;
+                    addr=r30+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60d5c;
+                        continue;
+                    }
+                    r2 = r19 & 1;
+                    r6 = r30 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6102c;
+                        run_61000(); return;
+                    }
+                    r2 = r0 + 48;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60f70;
+                        run_60e00(); return;
+                    }
+                    r30 = r30 + -1;
+                    r4 = r21 - r30;
+                    addr=r6+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x60dac:
+                    r4 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r6 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r9 = r4 - r6;
+                    if(r9 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60a6c;
+                        run_60a00(); return;
+                    }
+                    r4 = r9 < 17 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61268;
+                        run_61200(); return;
+                    }
+                    r6 = 7 << 16;
+                    r20 = r6 + 2732;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r17;
+                    r10 = r0 + 16;
+                    r17 = r20 + r0;
+                    r20 = r9 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60e04;
+                    run_60e00(); return;
+                case 0x60df0:
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r3 = r3 + 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60e68;
+                        run_60e00(); return;
+                    }
+                case 0x60e00:
+                    pc=0x60e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_60e00() throws ExecutionException { /* 0x60e00 - 0x61000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x60e00:
+                case 0x60e04:
+                    r2 = r2 + 1;
+                    r5 = r5 + 16;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r17;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r10;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60df0;
+                        run_60c00(); return;
+                    }
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    writePages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x60e40;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60e40:
+                    r10 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r20 = r20 + -16;
+                    r4 = r20 < 17 ? 1 : 0;
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60e04;
+                        continue;
+                    }
+                case 0x60e68:
+                    r9 = r20 + r0;
+                    r20 = r17 + r0;
+                    r17 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                case 0x60e74:
+                    r2 = r2 + 1;
+                    r5 = r5 + r9;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r20;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r9;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r5;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r2;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61120;
+                        run_61000(); return;
+                    }
+                    r3 = r3 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x60a6c;
+                    run_60a00(); return;
+                case 0x60ea4:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x60eb8;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60eb8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x60b6c;
+                    run_60a00(); return;
+                case 0x60ed0:
+                    r2 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x60cd8;
+                    run_60c00(); return;
+                case 0x60edc:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x60ef0;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60ef0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r3 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x60318;
+                    run_60200(); return;
+                case 0x60f04:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x60f18;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60f18:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x60b40;
+                    run_60a00(); return;
+                case 0x60f34:
+                    r4 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61010;
+                        run_61000(); return;
+                    }
+                    r30 = r21 + r0;
+                    r4 = r0 + 10;
+                case 0x60f48:
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r4!=0) {
+                        hi = (int)((r2 & 0xffffffffL) % (r4 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r4 & 0xffffffffL));
+                        }
+                        pc=0x60f54;
+                        continue;
+                    }
+                    if(r4!=0) {
+                    hi = (int)((r2 & 0xffffffffL) % (r4 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r4 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x60f54:
+                    r30 = r30 + -1;
+                    r6 = hi;
+                    r6 = r6 + 48;
+                    addr=r30+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = lo;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60f48;
+                        continue;
+                    }
+                case 0x60f70:
+                    r2 = r21 - r30;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x60f80:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x60f94;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60f94:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x60a1c;
+                    run_60a00(); return;
+                case 0x60fb0:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x60fc4;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60fc4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x60a5c;
+                    run_60a00(); return;
+                case 0x60fe0:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x60ff4;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x60ff4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                case 0x61000:
+                    pc=0x61000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_61000() throws ExecutionException { /* 0x61000 - 0x61200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x61000:
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x609dc;
+                    run_60800(); return;
+                case 0x61010:
+                    r6 = readPages[(r29+172)>>>12][((r29+172)>>>2)&0x3ff];
+                    r2 = r2 + 48;
+                    addr=r29+119;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r6;
+                    r30 = r29 + 119;
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x6102c:
+                    r6 = r21 - r30;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x6103c:
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r2;
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    run_60200(); return;
+                case 0x6104c:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x61060;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x61060:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x60c50;
+                    run_60c00(); return;
+                case 0x61074:
+                    r6 = readPages[(r29+172)>>>12][((r29+172)>>>2)&0x3ff];
+                    r2 = r0 + 48;
+                    addr=r29+119;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r6;
+                    r30 = r29 + 119;
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x61090:
+                    r6 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    addr=r6+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r6 = r6 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x6045c;
+                    run_60400(); return;
+                case 0x610ac:
+                    r4 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r5 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r4 + 4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r5;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x60298;
+                    run_60200(); return;
+                case 0x610cc:
+                    r6 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r6 = r6 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x6053c;
+                    run_60400(); return;
+                case 0x610e8:
+                    r6 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r6 = r6 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x606d0;
+                    run_60600(); return;
+                case 0x61104:
+                    r6 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r6 = r6 + 4;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    pc=0x606d0;
+                    run_60600(); return;
+                case 0x61120:
+                    r4 = r18 + r0;
+                    r5 = r16 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x61134;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x61134:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r5 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r3 = r29 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x60a6c;
+                    run_60a00(); return;
+                case 0x61150:
+                    r6 = 7 << 16;
+                    r20 = r6 + 2732;
+                    /* Next insn is delay slot */ 
+                    pc=0x60b18;
+                    run_60a00(); return;
+                case 0x61160:
+                    r2 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x60cc0;
+                        run_60c00(); return;
+                    }
+                    r4 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r6 = r29 + 120;
+                    /* Next insn is delay slot */ 
+                    r31=0x61184;
+                    pc=0x5fe00;
+                    run_5fe00(); return;
+                case 0x61184:
+                    /* Next insn is delay slot */ 
+                    pc=0x60cc0;
+                    run_60c00(); return;
+                case 0x6118c:
+                    r5 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r6 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r6;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x60298;
+                    run_60200(); return;
+                case 0x611ac:
+                    writePages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x611b8;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x611b8:
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r2;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r20;
+                    r23 = r0 + r0;
+                    r3 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x611d4:
+                    r23 = r0 + -1;
+                    r17 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60360;
+                    run_60200(); return;
+                case 0x611e4:
+                    r5 = r0 + 64;
+                    /* Next insn is delay slot */ 
+                    r31=0x611f0;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x611f0:
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x612c8;
+                        run_61200(); return;
+                    }
+                case 0x61200:
+                    pc=0x61200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_61200() throws ExecutionException { /* 0x61200 - 0x61400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x61200:
+                    r2 = r0 + 64;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x6025c;
+                    run_60200(); return;
+                case 0x61210:
+                    r2 = (r23&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61220;
+                        continue;
+                    }
+                    r23 = r0 + 6;
+                case 0x61220:
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r23;
+                    r2 = r23 + r0;
+                    if(r23 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61290;
+                        continue;
+                    }
+                case 0x61230:
+                    r8 = 7 << 16;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r2;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r20;
+                    r30 = r8 + 268;
+                    /* Next insn is delay slot */ 
+                    pc=0x60588;
+                    run_60400(); return;
+                case 0x61248:
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    writePages[(r29+164)>>>12][((r29+164)>>>2)&0x3ff] = r22;
+                    /* Next insn is delay slot */ 
+                    pc=0x60670;
+                    run_60600(); return;
+                case 0x61258:
+                    r2 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    writePages[(r29+164)>>>12][((r29+164)>>>2)&0x3ff] = r22;
+                    /* Next insn is delay slot */ 
+                    pc=0x60c28;
+                    run_60c00(); return;
+                case 0x61268:
+                    r4 = 7 << 16;
+                    r20 = r4 + 2732;
+                    /* Next insn is delay slot */ 
+                    pc=0x60e74;
+                    run_60e00(); return;
+                case 0x61278:
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r23;
+                    addr=r29+134;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r20;
+                    r23 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x604c8;
+                    run_60400(); return;
+                case 0x61290:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x61230;
+                    continue;
+                case 0x6129c:
+                    r4 = readPages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff];
+                    r17 = r5 + r0;
+                    r23 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r4 + 4;
+                    if(r23 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6103c;
+                        run_61000(); return;
+                    }
+                    writePages[(r29+236)>>>12][((r29+236)>>>2)&0x3ff] = r2;
+                    r23 = r0 + -1;
+                    r2 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x60358;
+                    run_60200(); return;
+                case 0x612c8:
+                    r3 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    r2 = r0 + 12;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x60cd8;
+                    run_60c00(); return;
+                case 0x61400:
+                    pc=0x61400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_61400() throws ExecutionException { /* 0x61400 - 0x61600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x61400:
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -752;
+                    writePages[(r29+708)>>>12][((r29+708)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = r2 & 8192;
+                    writePages[(r29+736)>>>12][((r29+736)>>>2)&0x3ff] = r30;
+                    writePages[(r29+720)>>>12][((r29+720)>>>2)&0x3ff] = r20;
+                    writePages[(r29+704)>>>12][((r29+704)>>>2)&0x3ff] = r16;
+                    writePages[(r29+740)>>>12][((r29+740)>>>2)&0x3ff] = r31;
+                    writePages[(r29+732)>>>12][((r29+732)>>>2)&0x3ff] = r23;
+                    writePages[(r29+728)>>>12][((r29+728)>>>2)&0x3ff] = r22;
+                    writePages[(r29+724)>>>12][((r29+724)>>>2)&0x3ff] = r21;
+                    writePages[(r29+716)>>>12][((r29+716)>>>2)&0x3ff] = r19;
+                    writePages[(r29+712)>>>12][((r29+712)>>>2)&0x3ff] = r18;
+                    writePages[(r29+748)>>>12][((r29+748)>>>2)&0x3ff] = f20;
+                    writePages[(r29+744)>>>12][((r29+744)>>>2)&0x3ff] = f21;
+                    r30 = r5 + r0;
+                    r16 = r6 + r0;
+                    r20 = r7 + r0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6146c;
+                        continue;
+                    }
+                    r2 = r2 | 8192;
+                    r4 = readPages[(r5+100)>>>12][((r5+100)>>>2)&0x3ff];
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -8193;
+                    r2 = r4 & r2;
+                    writePages[(r5+100)>>>12][((r5+100)>>>2)&0x3ff] = r2;
+                case 0x6146c:
+                    writePages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff] = r0;
+                    writePages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff] = r0;
+                    r21 = r0 + r0;
+                    writePages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff] = r0;
+                case 0x6147c:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r16 = r16 + 1;
+                    writePages[(r29+640)>>>12][((r29+640)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        run_61600(); return;
+                    }
+                case 0x61490:
+                    r4 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r3 = r4 + r2;
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 8;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6152c;
+                        continue;
+                    }
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61508;
+                        continue;
+                    }
+                case 0x614c0:
+                    r3 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r4 + r2;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6147c;
+                        continue;
+                    }
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    r2 = r2 + -1;
+                    r21 = r21 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r3;
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x614c0;
+                        continue;
+                    }
+                case 0x61508:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x61518;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x61518:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6147c;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x614c0;
+                    continue;
+                case 0x6152c:
+                    r3 = r0 + 37;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x616ec;
+                        run_61600(); return;
+                    }
+                    r18 = r0 + r0;
+                    r23 = r0 + r0;
+                case 0x61540:
+                    r16 = r16 + 1;
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r3 & 255;
+                    r5 = (r2&0xffffffffL) < (121&0xffffffffL) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6157c;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r2 = r2 << 2;
+                    r5 = r5 + 2772;
+                    r2 = r5 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x6157c:
+                    r3 = r4 + r3;
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r0 + 1;
+                    r3 = r3 & 3;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61598;
+                        continue;
+                    }
+                case 0x61594:
+                    r18 = r18 | 1;
+                case 0x61598:
+                    r2 = 4 << 16;
+                    r2 = r2 + 12800;
+                    r3 = r0 + 10;
+                    writePages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff] = r2;
+                    writePages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff] = r3;
+                    r19 = r0 + 3;
+                case 0x615b0:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61774;
+                        run_61600(); return;
+                    }
+                case 0x615c0:
+                    r2 = r18 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61694;
+                        run_61600(); return;
+                    }
+                case 0x615cc:
+                    r2 = r0 + 2;
+                    if(r19 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618b8;
+                        run_61800(); return;
+                    }
+                    r2 = r19 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x617f0;
+                        run_61600(); return;
+                    }
+                    r2 = r0 + 3;
+                    if(r19 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x619ec;
+                        run_61800(); return;
+                    }
+                    r2 = r0 + 4;
+                    if(r19 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61958;
+                        run_61800(); return;
+                    }
+                    r2 = r23 + -1;
+                case 0x61600:
+                    pc=0x61600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_61600() throws ExecutionException { /* 0x61600 - 0x61800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x61600:
+                    r2 = (r2&0xffffffffL) < (349&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62108;
+                        run_62000(); return;
+                    }
+                    writePages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff] = r0;
+                case 0x61610:
+                    r10 = r29 + 24;
+                    r19 = r18 | 1920;
+                    r3 = r0 + r0;
+                    r18 = r0 + r0;
+                    writePages[(r29+676)>>>12][((r29+676)>>>2)&0x3ff] = r0;
+                    writePages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff] = r0;
+                    writePages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff] = r0;
+                    writePages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff] = r0;
+                    r22 = r10 + r0;
+                    r11 = r0 + -1921;
+                case 0x61638:
+                    r6 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r6+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r5 = tmp;
+                    r2 = r5 + -43;
+                    r2 = r2 & 255;
+                    r7 = (r2&0xffffffffL) < (79&0xffffffffL) ? 1 : 0;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r2 = r2 << 2;
+                    r4 = r4 + 3256;
+                    r2 = r4 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x6167c:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6168c;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x6168c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        continue;
+                    }
+                case 0x61694:
+                    r4 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x616ac;
+                    continue;
+                case 0x616a4:
+                    r2 = r2 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                case 0x616ac:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r4 + r3;
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 8;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x615cc;
+                        run_61400(); return;
+                    }
+                    r3 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r21 = r21 + 1;
+                    r3 = r3 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r3;
+                    if(r3 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x616a4;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6167c;
+                    continue;
+                case 0x616ec:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6275c;
+                        run_62600(); return;
+                    }
+                case 0x616fc:
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    if(r4 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        continue;
+                    }
+                    r3 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r3 = r3 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r3;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r21 = r21 + 1;
+                    writePages[(r29+640)>>>12][((r29+640)>>>2)&0x3ff] = r2;
+                    r16 = r16 + 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61490;
+                        run_61400(); return;
+                    }
+                case 0x61740:
+                    r2 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x617b4;
+                    continue;
+                case 0x6174c:
+                    r18 = r18 | 1;
+                case 0x61750:
+                    r2 = 6 << 16;
+                    r2 = r2 + -2048;
+                    writePages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r3 = r0 + 8;
+                    writePages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff] = r3;
+                    r19 = r0 + 3;
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x615c0;
+                        run_61400(); return;
+                    }
+                case 0x61774:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x61784;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x61784:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x615c0;
+                        run_61400(); return;
+                    }
+                case 0x6178c:
+                    r3 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x617b0;
+                        continue;
+                    }
+                    addr=r30+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        continue;
+                    }
+                case 0x617b0:
+                    r2 = r0 + -1;
+                case 0x617b4:
+                    f20 = readPages[(r29+748)>>>12][((r29+748)>>>2)&0x3ff];
+                    r31 = readPages[(r29+740)>>>12][((r29+740)>>>2)&0x3ff];
+                    r30 = readPages[(r29+736)>>>12][((r29+736)>>>2)&0x3ff];
+                    r23 = readPages[(r29+732)>>>12][((r29+732)>>>2)&0x3ff];
+                    r22 = readPages[(r29+728)>>>12][((r29+728)>>>2)&0x3ff];
+                    r21 = readPages[(r29+724)>>>12][((r29+724)>>>2)&0x3ff];
+                    r20 = readPages[(r29+720)>>>12][((r29+720)>>>2)&0x3ff];
+                    r19 = readPages[(r29+716)>>>12][((r29+716)>>>2)&0x3ff];
+                    r18 = readPages[(r29+712)>>>12][((r29+712)>>>2)&0x3ff];
+                    r17 = readPages[(r29+708)>>>12][((r29+708)>>>2)&0x3ff];
+                    r16 = readPages[(r29+704)>>>12][((r29+704)>>>2)&0x3ff];
+                    f21 = readPages[(r29+744)>>>12][((r29+744)>>>2)&0x3ff];
+                    r29 = r29 + 752;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x617f0:
+                    r2 = r0 + 1;
+                    if(r19 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61958;
+                        run_61800(); return;
+                    }
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61808;
+                        run_61800(); return;
+                    }
+                case 0x61800:
+                    pc=0x61800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_61800() throws ExecutionException { /* 0x61800 - 0x61a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x61800:
+                    r23 = r0 + -1;
+                case 0x61808:
+                    r18 = r18 & 16;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62048;
+                        run_62000(); return;
+                    }
+                    r10 = r29 + 24;
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r18 = r0 + r0;
+                    r19 = r10 + r0;
+                case 0x61824:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r19 + r3;
+                    addr=r3+352;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618a4;
+                        continue;
+                    }
+                case 0x61840:
+                    r3 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r3 = r3 + -1;
+                    r18 = r18 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r3;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    if(r23 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618ac;
+                        continue;
+                    }
+                    if(r3 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61824;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x61878;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x61878:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618ac;
+                        continue;
+                    }
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r19 + r3;
+                    addr=r3+352;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61840;
+                        continue;
+                    }
+                case 0x618a4:
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        run_61600(); return;
+                    }
+                case 0x618ac:
+                    r21 = r21 + r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x618b8:
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618c4;
+                        continue;
+                    }
+                    r23 = r0 + -1;
+                case 0x618c4:
+                    r2 = r18 & 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6235c;
+                        run_62200(); return;
+                    }
+                    r18 = r18 & 16;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x623fc;
+                        run_62200(); return;
+                    }
+                    r4 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r18 = r0 + r0;
+                case 0x618e8:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r4 + r3;
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 8;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618ac;
+                        continue;
+                    }
+                    r3 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r3 = r3 + -1;
+                    r18 = r18 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r3;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    if(r23 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618ac;
+                        continue;
+                    }
+                    if(r3 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618e8;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x61940;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x61940:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x618ac;
+                        continue;
+                    }
+                    r4 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x618e8;
+                    continue;
+                case 0x61958:
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61964;
+                        continue;
+                    }
+                    r23 = r0 + 1;
+                case 0x61964:
+                    r2 = r18 & 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6224c;
+                        run_62200(); return;
+                    }
+                    r18 = r18 & 16;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62718;
+                        run_62600(); return;
+                    }
+                    r18 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x619b4;
+                    continue;
+                case 0x61988:
+                    r3 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r18 = r18 + r2;
+                    r23 = r23 - r2;
+                    r2 = r3 + r2;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x619ac;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x619ac:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62704;
+                        run_62600(); return;
+                    }
+                case 0x619b4:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r3 = r2 < r23 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61988;
+                        continue;
+                    }
+                    r2 = r2 - r23;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r18 = r18 + r23;
+                    r8 = r2 + r23;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r8;
+                    r21 = r21 + r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x619ec:
+                    r2 = r23 + -1;
+                    r2 = (r2&0xffffffffL) < (349&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62038;
+                        run_62000(); return;
+                    }
+                    r6 = r0 + r0;
+                case 0x61a00:
+                    pc=0x61a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_61a00() throws ExecutionException { /* 0x61a00 - 0x61c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x61a00:
+                    r10 = r29 + 24;
+                    r4 = 7 << 16;
+                    r11 = r20 + r0;
+                    r20 = r16 + r0;
+                    r16 = readPages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff];
+                    r18 = r18 | 3456;
+                    r8 = r0 + r0;
+                    r19 = r10 + r0;
+                    r7 = r0 + 512;
+                    r22 = r4 + 3884;
+                case 0x61a28:
+                    r5 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r3 + -43;
+                    r2 = r2 & 255;
+                    r9 = (r2&0xffffffffL) < (78&0xffffffffL) ? 1 : 0;
+                    if(r9 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ecc;
+                        run_61e00(); return;
+                    }
+                    r4 = 7 << 16;
+                    r2 = r2 << 2;
+                    r4 = r4 + 3572;
+                    r2 = r4 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x61a6c:
+                    r2 = r3 + r18;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        continue;
+                    }
+                    r2 = r0 + -385;
+                    r19 = r19 & r2;
+                case 0x61a80:
+                    addr=r22+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r22 = r22 + 1;
+                case 0x61a88:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r23 = r23 + -1;
+                    r2 = r2 + -1;
+                    r21 = r21 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61cb4;
+                        run_61c00(); return;
+                    }
+                case 0x61aa4:
+                    r6 = r6 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r6;
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61638;
+                        run_61600(); return;
+                    }
+                case 0x61ab4:
+                    r4 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61cf4;
+                        run_61c00(); return;
+                    }
+                case 0x61ac4:
+                    r2 = r3 + -1;
+                    r2 = (r2&0xffffffffL) < (2&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62960;
+                        run_62800(); return;
+                    }
+                    r2 = r18 + -1;
+                    r2 = (r2&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61b5c;
+                        continue;
+                    }
+                    r2 = r18 < 3 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x628e0;
+                        run_62800(); return;
+                    }
+                    r2 = r0 + 3;
+                    r7 = r18 & 255;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61b5c;
+                        continue;
+                    }
+                    writePages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff] = r16;
+                    r23 = r22 + r0;
+                    r16 = r7 + r0;
+                    r18 = r10 + r0;
+                case 0x61b10:
+                    r23 = r23 + -1;
+                    addr=r23+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x61b28;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x61b28:
+                    r3 = r16 + -1;
+                    r2 = r23 + r21;
+                    r16 = r3 & 255;
+                    r4 = r2 - r22;
+                    r2 = r16 << 24;
+                    r2 = r2 >> 24;
+                    r2 = r2 < 4 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61b10;
+                        continue;
+                    }
+                    r16 = readPages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff];
+                    r10 = r18 + r0;
+                    r21 = r4 + r0;
+                    r22 = r23 + r0;
+                case 0x61b5c:
+                    r2 = r19 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61be4;
+                        continue;
+                    }
+                    r2 = r19 & 1024;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62920;
+                        run_62800(); return;
+                    }
+                    addr=r22+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r2 = r0 + 101;
+                    r23 = r22 + -1;
+                    r7 = r21 + -1;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61bbc;
+                        continue;
+                    }
+                    r2 = r0 + 69;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61bbc;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x61bac;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x61bac:
+                    addr=r22+-2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r10 = readPages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff];
+                    r23 = r22 + -2;
+                    r7 = r21 + -2;
+                case 0x61bbc:
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+684)>>>12][((r29+684)>>>2)&0x3ff] = r7;
+                    writePages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x61bd4;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x61bd4:
+                    r7 = readPages[(r29+684)>>>12][((r29+684)>>>2)&0x3ff];
+                    r10 = readPages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff];
+                    r21 = r7 + r0;
+                    r22 = r23 + r0;
+                case 0x61be4:
+                    r2 = r19 & 16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6147c;
+                        run_61400(); return;
+                    }
+                    r4 = r19 & 1536;
+                    r2 = r0 + 1024;
+                    addr=r22+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6277c;
+                        run_62600(); return;
+                    }
+                case 0x61c00:
+                    pc=0x61c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_61c00() throws ExecutionException { /* 0x61c00 - 0x61e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x61c00:
+                    r3 = readPages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62654;
+                        run_62600(); return;
+                    }
+                case 0x61c14:
+                    r4 = r17 + r0;
+                    r5 = r10 + r0;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x61c28;
+                    pc=0x66c00;
+                    run_66c00(); return;
+                case 0x61c28:
+                    r2 = r19 & 1;
+                    f20 = f0;
+                    f21 = f1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62544;
+                        run_62400(); return;
+                    }
+                case 0x61c38:
+                    r2 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r20 = r20 + 4;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = f20;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = f21;
+                case 0x61c48:
+                    r3 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x61c60:
+                    r2 = r19 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61a6c;
+                        run_61a00(); return;
+                    }
+                    r2 = r0 + -129;
+                    r5 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    r19 = r19 & r2;
+                    r2 = readPages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff];
+                    r5 = r5 + 1;
+                    writePages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff] = r5;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61a88;
+                        run_61a00(); return;
+                    }
+                    r2 = r2 + -1;
+                    writePages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r23 = r23 + 1;
+                    r2 = r2 + -1;
+                    r23 = r23 + -1;
+                    r21 = r21 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61aa4;
+                        run_61a00(); return;
+                    }
+                case 0x61cb4:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    writePages[(r29+680)>>>12][((r29+680)>>>2)&0x3ff] = r3;
+                    writePages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff] = r10;
+                    writePages[(r29+692)>>>12][((r29+692)>>>2)&0x3ff] = r11;
+                    /* Next insn is delay slot */ 
+                    r31=0x61cd0;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x61cd0:
+                    r3 = readPages[(r29+680)>>>12][((r29+680)>>>2)&0x3ff];
+                    r10 = readPages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff];
+                    r11 = readPages[(r29+692)>>>12][((r29+692)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61638;
+                        run_61600(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x61ab4;
+                    run_61a00(); return;
+                case 0x61cf4:
+                    r2 = r0 + -257;
+                    r19 = r19 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61ac4;
+                    run_61a00(); return;
+                case 0x61d04:
+                    r2 = r19 & 512;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    r2 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    r4 = r0 + -641;
+                    r19 = r19 & r4;
+                    writePages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61d28:
+                    r2 = r19 & 128;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    r2 = r0 + -129;
+                    r19 = r19 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61d44:
+                    r2 = r0 + 7;
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    r18 = r0 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61d5c:
+                    r2 = r0 + 6;
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    r18 = r0 + 7;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61d74:
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x624ac;
+                        run_62400(); return;
+                    }
+                    r4 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62590;
+                        run_62400(); return;
+                    }
+                case 0x61d8c:
+                    r2 = r0 + 1;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61da4;
+                        continue;
+                    }
+                    r2 = r0 + 4;
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                case 0x61da4:
+                    r18 = r18 + 1;
+                    r18 = r18 << 24;
+                    r18 = r18 >> 24;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61db8:
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x624c4;
+                        run_62400(); return;
+                    }
+                    r2 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61cf4;
+                        continue;
+                    }
+                    r4 = r19 & 1792;
+                    r2 = r0 + 1792;
+                    if(r4 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ac4;
+                        run_61a00(); return;
+                    }
+                    r19 = r19 & r11;
+                    r18 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61df0:
+                    r2 = r0 + 2;
+                    if(r18 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    r18 = r0 + 3;
+                case 0x61e00:
+                    pc=0x61e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_61e00() throws ExecutionException { /* 0x61e00 - 0x62000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x61e00:
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61e08:
+                    r2 = r19 & 1280;
+                    r4 = r0 + 1024;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61e34;
+                        continue;
+                    }
+                    r2 = r19 & 1024;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    r2 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ac4;
+                        run_61a00(); return;
+                    }
+                case 0x61e34:
+                    r2 = r19 & 512;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61e54;
+                        continue;
+                    }
+                    r4 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    r2 = readPages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff];
+                    writePages[(r29+676)>>>12][((r29+676)>>>2)&0x3ff] = r22;
+                    r4 = r4 - r2;
+                    writePages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff] = r4;
+                case 0x61e54:
+                    r19 = r19 & r11;
+                    r19 = r19 | 384;
+                    writePages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61e68:
+                    r2 = r0 + 1;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ab4;
+                        run_61a00(); return;
+                    }
+                    r3 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x61e80:
+                    r2 = r18 & 1536;
+                    if(r2 != r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ecc;
+                        continue;
+                    }
+                    r2 = r0 + -513;
+                    r18 = r18 & r2;
+                    r18 = r18 | 1280;
+                    r16 = r0 + 16;
+                case 0x61e9c:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    addr=r19+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r2 + -1;
+                    r19 = r19 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61fc4;
+                        continue;
+                    }
+                case 0x61eb8:
+                    r5 = r5 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r5;
+                case 0x61ec0:
+                    r23 = r23 + -1;
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61a28;
+                        run_61a00(); return;
+                    }
+                case 0x61ecc:
+                    r2 = r18 & 256;
+                    writePages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff] = r16;
+                    r16 = r20 + r0;
+                    r20 = r11 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ef8;
+                        continue;
+                    }
+                    r2 = ((r10 & 0xffffffffL) < (r19 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62620;
+                        run_62600(); return;
+                    }
+                case 0x61ef0:
+                    if(r10 == r19) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        run_61600(); return;
+                    }
+                case 0x61ef8:
+                    r2 = r18 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x624e4;
+                        run_62400(); return;
+                    }
+                case 0x61f04:
+                    r10 = r19 - r10;
+                    r23 = r10 + r8;
+                    r21 = r21 + r23;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x61f18:
+                    r2 = r16 < 11 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ecc;
+                        continue;
+                    }
+                    r2 = r0 + -2945;
+                    r18 = r18 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61e9c;
+                    continue;
+                case 0x61f34:
+                    r2 = r18 & 128;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ecc;
+                        continue;
+                    }
+                    r2 = r0 + -129;
+                    r18 = r18 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61e9c;
+                    continue;
+                case 0x61f50:
+                    r2 = r16 << 1;
+                    r2 = r2 + r22;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r16 = tmp;
+                    r2 = r0 + -2945;
+                    r18 = r18 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61e9c;
+                    continue;
+                case 0x61f6c:
+                    r2 = r18 & 2048;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61e9c;
+                        continue;
+                    }
+                    if(r16 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61f88;
+                        continue;
+                    }
+                    r18 = r18 | 512;
+                    r16 = r0 + 8;
+                case 0x61f88:
+                    r2 = r18 & 1024;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62580;
+                        run_62400(); return;
+                    }
+                    r2 = r0 + -897;
+                    r18 = r18 & r2;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61fac;
+                        continue;
+                    }
+                    r6 = r6 + -1;
+                    r23 = r23 + 1;
+                case 0x61fac:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r8 = r8 + 1;
+                    r2 = r2 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61eb8;
+                        continue;
+                    }
+                case 0x61fc4:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    writePages[(r29+680)>>>12][((r29+680)>>>2)&0x3ff] = r6;
+                    writePages[(r29+684)>>>12][((r29+684)>>>2)&0x3ff] = r7;
+                    writePages[(r29+688)>>>12][((r29+688)>>>2)&0x3ff] = r8;
+                    writePages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff] = r10;
+                    writePages[(r29+692)>>>12][((r29+692)>>>2)&0x3ff] = r11;
+                    /* Next insn is delay slot */ 
+                    r31=0x61fe8;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x61fe8:
+                    r6 = readPages[(r29+680)>>>12][((r29+680)>>>2)&0x3ff];
+                    r7 = readPages[(r29+684)>>>12][((r29+684)>>>2)&0x3ff];
+                    r8 = readPages[(r29+688)>>>12][((r29+688)>>>2)&0x3ff];
+                    r10 = readPages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff];
+                    r11 = readPages[(r29+692)>>>12][((r29+692)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ec0;
+                        continue;
+                    }
+                case 0x62000:
+                    pc=0x62000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_62000() throws ExecutionException { /* 0x62000 - 0x62200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x62000:
+                    /* Next insn is delay slot */ 
+                    pc=0x61ecc;
+                    run_61e00(); return;
+                case 0x6200c:
+                    r2 = r16 << 1;
+                    r2 = r2 + r22;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r16 = tmp;
+                    r2 = r16 < 9 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61ecc;
+                        run_61e00(); return;
+                    }
+                    r2 = r0 + -2945;
+                    r18 = r18 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61e9c;
+                    run_61e00(); return;
+                case 0x62038:
+                    r6 = r23 + -349;
+                    r23 = r0 + 349;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a00;
+                    run_61a00(); return;
+                case 0x62048:
+                    r18 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r10 = r29 + 24;
+                    r19 = r20 + 4;
+                    r22 = r10 + r0;
+                    r20 = r18 + r0;
+                case 0x6205c:
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r22 + r3;
+                    addr=r3+352;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x620dc;
+                        continue;
+                    }
+                    r3 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r20 = r20 + 1;
+                    r3 = r3 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r3;
+                    r3 = r2 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r3;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r23 = r23 + -1;
+                    addr=r20+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r23 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x620dc;
+                        continue;
+                    }
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6205c;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x620cc;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x620cc:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6205c;
+                        continue;
+                    }
+                    if(r18 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        run_61600(); return;
+                    }
+                case 0x620dc:
+                    r18 = r20 - r18;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        run_61600(); return;
+                    }
+                    r3 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    addr=r20+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r3 + 1;
+                    writePages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff] = r3;
+                    r20 = r19 + r0;
+                    r21 = r21 + r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x62108:
+                    r23 = r23 + -349;
+                    writePages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff] = r23;
+                    r23 = r0 + 349;
+                    /* Next insn is delay slot */ 
+                    pc=0x61610;
+                    run_61600(); return;
+                case 0x6211c:
+                    r2 = 4 << 16;
+                    r2 = r2 + 12800;
+                    writePages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff] = r2;
+                    writePages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff] = r0;
+                    r19 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x615b0;
+                    run_61400(); return;
+                case 0x62138:
+                    r18 = r18 | 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x61540;
+                    run_61400(); return;
+                case 0x62144:
+                    r18 = r18 | 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x61540;
+                    run_61400(); return;
+                case 0x62150:
+                    r18 = r18 | 64;
+                    r19 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x615b0;
+                    run_61400(); return;
+                case 0x62160:
+                    r5 = r16 + r0;
+                    r4 = r29 + 376;
+                    /* Next insn is delay slot */ 
+                    r31=0x62170;
+                    pc=0x66800;
+                    run_66800(); return;
+                case 0x62170:
+                    r16 = r2 + r0;
+                    r18 = r18 | 64;
+                    r19 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x615b0;
+                    run_61400(); return;
+                case 0x62184:
+                    r18 = r18 | 512;
+                case 0x62188:
+                    r2 = 6 << 16;
+                    r2 = r2 + -2048;
+                    r3 = r0 + 16;
+                    writePages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff] = r2;
+                    writePages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff] = r3;
+                    r19 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x615b0;
+                    run_61400(); return;
+                case 0x621a8:
+                    r18 = r18 | 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61540;
+                    run_61400(); return;
+                case 0x621b4:
+                    r19 = r0 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x615b0;
+                    run_61400(); return;
+                case 0x621c0:
+                    r2 = r23 << 1;
+                    r23 = r23 << 3;
+                    r2 = r2 + r23;
+                    r3 = r3 + -48;
+                    r23 = r3 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61540;
+                    run_61400(); return;
+                case 0x621dc:
+                    r18 = r18 | 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x61540;
+                    run_61400(); return;
+                case 0x621e8:
+                    r2 = 6 << 16;
+                    r2 = r2 + -2048;
+                    r3 = r0 + 10;
+                    writePages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff] = r2;
+                    writePages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff] = r3;
+                    r19 = r0 + 3;
+                case 0x62200:
+                    pc=0x62200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_62200() throws ExecutionException { /* 0x62200 - 0x62400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x62200:
+                    /* Next insn is delay slot */ 
+                    pc=0x615b0;
+                    run_61400(); return;
+                case 0x62208:
+                    r19 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x615b0;
+                    run_61400(); return;
+                case 0x62214:
+                    r18 = r18 | 544;
+                    /* Next insn is delay slot */ 
+                    pc=0x62188;
+                    run_62000(); return;
+                case 0x62220:
+                    r2 = r18 & 16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6147c;
+                        run_61400(); return;
+                    }
+                    r2 = r18 & 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x627a0;
+                        run_62600(); return;
+                    }
+                    r2 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r20 = r20 + 4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r21&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x6224c:
+                    r3 = r29 + 632;
+                    r4 = r3 + r0;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    r18 = r18 & 16;
+                    writePages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x6226c;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x6226c:
+                    writePages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff] = r18;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x625e4;
+                        run_62400(); return;
+                    }
+                    r18 = r0 + r0;
+                case 0x6227c:
+                    r22 = r0 + r0;
+                    writePages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff] = r16;
+                    r19 = readPages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff];
+                    r16 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    writePages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff] = r20;
+                    r20 = r22 + r0;
+                case 0x62294:
+                    /* Next insn is delay slot */ 
+                    r31=0x6229c;
+                    pc=0x5a800;
+                    run_5a800(); return;
+                case 0x6229c:
+                    if(r2 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        run_61600(); return;
+                    }
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r4 = r29 + 24;
+                    r3 = r4 + r20;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r22 = r20 + 1;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r3 = r3 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r3;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    r5 = r18 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r4 = r17 + r0;
+                    r6 = r29 + 24;
+                    r7 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x622ec;
+                    pc=0x66000;
+                    run_66000(); return;
+                case 0x622ec:
+                    r5 = r0 + -1;
+                    if(r2 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        run_61600(); return;
+                    }
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x626e0;
+                        run_62600(); return;
+                    }
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6230c;
+                        continue;
+                    }
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r0;
+                case 0x6230c:
+                    r21 = r21 + r22;
+                    r23 = r23 + -1;
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x626f8;
+                        run_62600(); return;
+                    }
+                    r18 = r18 + 4;
+                    r20 = r0 + r0;
+                case 0x62324:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x625b0;
+                        run_62400(); return;
+                    }
+                case 0x62334:
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62294;
+                        continue;
+                    }
+                    r16 = readPages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff];
+                    r20 = readPages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff];
+                case 0x62344:
+                    r3 = readPages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61c48;
+                        run_61c00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x6235c:
+                    r3 = r29 + 632;
+                    r4 = r3 + r0;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    r18 = r18 & 16;
+                    writePages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x6237c;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x6237c:
+                    writePages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff] = r18;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x625f4;
+                        run_62400(); return;
+                    }
+                    r19 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r20 = r20 + 4;
+                case 0x62390:
+                    r6 = r0 + r0;
+                    writePages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff] = r16;
+                    r22 = r0 + -2;
+                    r16 = r6 + r0;
+                case 0x623a0:
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r3 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r3 + r2;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x623d0;
+                        continue;
+                    }
+                    if(r23 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x627b4;
+                        run_62600(); return;
+                    }
+                case 0x623d0:
+                    r16 = readPages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff];
+                case 0x623d4:
+                    r3 = readPages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6147c;
+                        run_61400(); return;
+                    }
+                    r3 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r0;
+                    r3 = r3 + 1;
+                    writePages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x623fc:
+                    r19 = r20 + 4;
+                case 0x62400:
+                    pc=0x62400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_62400() throws ExecutionException { /* 0x62400 - 0x62600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x62400:
+                    r20 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r18 = r20 + r0;
+                case 0x6240c:
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r5 + r3;
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r3 = r3 & 8;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62488;
+                        continue;
+                    }
+                    r3 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r18 = r18 + 1;
+                    r3 = r3 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r3;
+                    r3 = r2 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r3;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r23 = r23 + -1;
+                    addr=r18+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r23 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62488;
+                        continue;
+                    }
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6240c;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x62480;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x62480:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6240c;
+                        continue;
+                    }
+                case 0x62488:
+                    r3 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    addr=r18+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r3 + 1;
+                    r18 = r18 - r20;
+                    r21 = r21 + r18;
+                    writePages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff] = r3;
+                    r20 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x624ac:
+                    r2 = r0 + 2;
+                    if(r3 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61d8c;
+                        run_61c00(); return;
+                    }
+                    r3 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x624c4:
+                    r2 = r0 + 3;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61da4;
+                        run_61c00(); return;
+                    }
+                    r2 = r0 + 5;
+                    if(r18 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61da4;
+                        run_61c00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x61ab4;
+                    run_61a00(); return;
+                case 0x624e4:
+                    r3 = readPages[(r29+660)>>>12][((r29+660)>>>2)&0x3ff];
+                    r7 = readPages[(r29+652)>>>12][((r29+652)>>>2)&0x3ff];
+                    addr=r19+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r5 = r10 + r0;
+                    writePages[(r29+688)>>>12][((r29+688)>>>2)&0x3ff] = r8;
+                    writePages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff] = r10;
+                    r4 = r17 + r0;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    r31=0x6250c;
+                    return;
+                case 0x6250c:
+                    r3 = r18 & 32;
+                    r8 = readPages[(r29+688)>>>12][((r29+688)>>>2)&0x3ff];
+                    r10 = readPages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62600;
+                        run_62600(); return;
+                    }
+                case 0x62520:
+                    r3 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r20 = r20 + 4;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                case 0x6252c:
+                    r3 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x61f04;
+                    run_61e00(); return;
+                case 0x62544:
+                    r9 = r19 & 2;
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61c38;
+                        run_61c00(); return;
+                    }
+                    f12 = f0;
+                    f13 = f1;
+                    r18 = r20 + 4;
+                    r19 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x62564;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x62564:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62878;
+                        run_62800(); return;
+                    }
+                    f20=Float.floatToRawIntBits((float)(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL))));
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = f20;
+                    r20 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x61c48;
+                    run_61c00(); return;
+                case 0x62580:
+                    r2 = r0 + -1409;
+                    r18 = r18 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x61e9c;
+                    run_61e00(); return;
+                case 0x62590:
+                    r4 = r19 & 1792;
+                    r2 = r0 + 1792;
+                    if(r4 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61d8c;
+                        run_61c00(); return;
+                    }
+                    r19 = r19 & r11;
+                    r3 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x61a80;
+                    run_61a00(); return;
+                case 0x625b0:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x625c0;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x625c0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62334;
+                        run_62200(); return;
+                    }
+                    r22 = r20 + r0;
+                    r16 = readPages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff];
+                    r20 = readPages[(r29+672)>>>12][((r29+672)>>>2)&0x3ff];
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62344;
+                        run_62200(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6178c;
+                    run_61600(); return;
+                case 0x625e4:
+                    r18 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r20 = r20 + 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x6227c;
+                    run_62200(); return;
+                case 0x625f4:
+                    r19 = r29 + 640;
+                    /* Next insn is delay slot */ 
+                    pc=0x62390;
+                    run_62200(); return;
+                case 0x62600:
+                    pc=0x62600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_62600() throws ExecutionException { /* 0x62600 - 0x62800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x62600:
+                    r3 = r18 & 4;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62520;
+                        run_62400(); return;
+                    }
+                    r3 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r20 = r20 + 4;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x6252c;
+                    run_62400(); return;
+                case 0x62620:
+                    addr=r19+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r22 = r19 + -1;
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+688)>>>12][((r29+688)>>>2)&0x3ff] = r8;
+                    writePages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff] = r10;
+                    r19 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x62644;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x62644:
+                    r10 = readPages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff];
+                    r8 = readPages[(r29+688)>>>12][((r29+688)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x61ef0;
+                    run_61e00(); return;
+                case 0x62654:
+                    r3 = readPages[(r29+676)>>>12][((r29+676)>>>2)&0x3ff];
+                    r6 = r0 + r0;
+                    r5 = r3 + 1;
+                    r4 = r17 + r0;
+                    r7 = r0 + 10;
+                    writePages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x62674;
+                    pc=0x43200;
+                    run_43200(); return;
+                case 0x62674:
+                    r3 = readPages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff];
+                    r22 = readPages[(r29+676)>>>12][((r29+676)>>>2)&0x3ff];
+                    r10 = readPages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff];
+                    r6 = r2 - r3;
+                case 0x62684:
+                    r2 = r29 + 363;
+                    r2 = ((r22 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62698;
+                        continue;
+                    }
+                    r22 = r29 + 362;
+                case 0x62698:
+                    r2 = 7 << 16;
+                    r4 = r22 + r0;
+                    r5 = r2 + 2764;
+                    writePages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x626b0;
+                    pc=0x42000;
+                    run_42000(); return;
+                case 0x626b0:
+                    r10 = readPages[(r29+696)>>>12][((r29+696)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r5 = r10 + r0;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x626c8;
+                    pc=0x66c00;
+                    run_66c00(); return;
+                case 0x626c8:
+                    r2 = r19 & 1;
+                    f20 = f0;
+                    f21 = f1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62544;
+                        run_62400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x61c38;
+                    run_61c00(); return;
+                case 0x626e0:
+                    r3 = r0 + -2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6230c;
+                        run_62200(); return;
+                    }
+                    r20 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x62324;
+                    run_62200(); return;
+                case 0x626f8:
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x62324;
+                    run_62200(); return;
+                case 0x62704:
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        run_61600(); return;
+                    }
+                    r21 = r21 + r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x62718:
+                    r5 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r30;
+                    r6 = r0 + 1;
+                    r7 = r23 + r0;
+                    r18 = r20 + 4;
+                    /* Next insn is delay slot */ 
+                    r31=0x62738;
+                    pc=0x69000;
+                    run_69000(); return;
+                case 0x62738:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        run_61600(); return;
+                    }
+                    r3 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    r21 = r2 + r21;
+                    r3 = r3 + 1;
+                    writePages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff] = r3;
+                    r20 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x6275c:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6276c;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x6276c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x616fc;
+                        run_61600(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6178c;
+                    run_61600(); return;
+                case 0x6277c:
+                    r3 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    r4 = readPages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff];
+                    r18 = r3 - r4;
+                    r6 = r0 - r18;
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62684;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x61c14;
+                    run_61c00(); return;
+                case 0x627a0:
+                    r2 = readPages[(r20+0)>>>12][((r20+0)>>>2)&0x3ff];
+                    r20 = r20 + 4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r21;
+                    /* Next insn is delay slot */ 
+                    pc=0x6147c;
+                    run_61400(); return;
+                case 0x627b4:
+                    /* Next insn is delay slot */ 
+                    r31=0x627bc;
+                    pc=0x5a800;
+                    run_5a800(); return;
+                case 0x627bc:
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        run_61600(); return;
+                    }
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r4 = r29 + 24;
+                    r18 = r16 + 1;
+                    r16 = r4 + r16;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r3 = readPages[(r29+656)>>>12][((r29+656)>>>2)&0x3ff];
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r4 = r4 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    r4 = r17 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    r5 = r19 + r0;
+                case 0x62800:
+                    pc=0x62800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_62800() throws ExecutionException { /* 0x62800 - 0x62a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x62800:
+                    r6 = r29 + 24;
+                    r7 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x62810;
+                    pc=0x66000;
+                    run_66000(); return;
+                case 0x62810:
+                    r4 = r0 + -1;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        run_61600(); return;
+                    }
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62894;
+                        continue;
+                    }
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r0;
+                    r4 = r0 + r0;
+                case 0x6282c:
+                    /* Next insn is delay slot */ 
+                    r31=0x62834;
+                    pc=0x65e00;
+                    run_65e00(); return;
+                case 0x62834:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x629a0;
+                        continue;
+                    }
+                    r16 = readPages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff];
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x623d4;
+                        run_62200(); return;
+                    }
+                case 0x62848:
+                    r18 = r18 + -1;
+                    r5 = r29 + 24;
+                    r2 = r5 + r18;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r5 = tmp;
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x62868;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x62868:
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62848;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x623d4;
+                    run_62200(); return;
+                case 0x62878:
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x62884;
+                    pc=0x66a00;
+                    run_66a00(); return;
+                case 0x62884:
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = f0;
+                    r20 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x61c48;
+                    run_61c00(); return;
+                case 0x62894:
+                    if(r2 != r22) {
+                        /* Next insn is delay slot */ 
+                        pc=0x629c4;
+                        continue;
+                    }
+                    r16 = r18 + r0;
+                case 0x628a0:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x623a0;
+                        run_62200(); return;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x628c0;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x628c0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x623a0;
+                        run_62200(); return;
+                    }
+                    r6 = r16 + r0;
+                    r16 = readPages[(r29+664)>>>12][((r29+664)>>>2)&0x3ff];
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6178c;
+                        run_61600(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x623d4;
+                    run_62200(); return;
+                case 0x628e0:
+                    r2 = ((r10 & 0xffffffffL) < (r22 & 0xffffffffL)) ? 1 : 0;
+                    r23 = r22 + r0;
+                    r16 = r10 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        run_61600(); return;
+                    }
+                case 0x628f4:
+                    r23 = r23 + -1;
+                    addr=r23+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6290c;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x6290c:
+                    if(r23 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x628f4;
+                        continue;
+                    }
+                    r2 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x617b4;
+                    run_61600(); return;
+                case 0x62920:
+                    r2 = ((r10 & 0xffffffffL) < (r22 & 0xffffffffL)) ? 1 : 0;
+                    r23 = r22 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        run_61600(); return;
+                    }
+                    r16 = r10 + r0;
+                case 0x62934:
+                    r23 = r23 + -1;
+                    addr=r23+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6294c;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x6294c:
+                    if(r23 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62934;
+                        continue;
+                    }
+                    r2 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x617b4;
+                    run_61600(); return;
+                case 0x62960:
+                    r2 = ((r10 & 0xffffffffL) < (r22 & 0xffffffffL)) ? 1 : 0;
+                    r23 = r22 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x61740;
+                        run_61600(); return;
+                    }
+                    r16 = r10 + r0;
+                case 0x62974:
+                    r23 = r23 + -1;
+                    addr=r23+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6298c;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x6298c:
+                    if(r23 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x62974;
+                        continue;
+                    }
+                    r2 = readPages[(r29+648)>>>12][((r29+648)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x617b4;
+                    run_61600(); return;
+                case 0x629a0:
+                    r3 = readPages[(r29+668)>>>12][((r29+668)>>>2)&0x3ff];
+                    r21 = r21 + r18;
+                    r23 = r23 + -1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x629d0;
+                        continue;
+                    }
+                    r19 = r19 + 4;
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x628a0;
+                    continue;
+                case 0x629c4:
+                    r4 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x6282c;
+                    continue;
+                case 0x629d0:
+                    r16 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x628a0;
+                    continue;
+                case 0x62a00:
+                    pc=0x62a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_62a00() throws ExecutionException { /* 0x62a00 - 0x62c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x62a00:
+                    r5 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x48860;
+                    run_48800(); return;
+                case 0x62c00:
+                    pc=0x62c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_62c00() throws ExecutionException { /* 0x62c00 - 0x62e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x62c00:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x48cd0;
+                    run_48c00(); return;
+                case 0x62e00:
+                    pc=0x62e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_62e00() throws ExecutionException { /* 0x62e00 - 0x63000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x62e00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x48960;
+                    run_48800(); return;
+                case 0x63000:
+                    pc=0x63000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_63000() throws ExecutionException { /* 0x63000 - 0x63200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x63000:
+                    r29 = r29 + -32;
+                    r2 = r4 + r0;
+                    r4 = r29 + 40;
+                    r3 = r5 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r6;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r7;
+                    r5 = r2 + r0;
+                    r7 = r6 + r0;
+                    r6 = r3 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x63038;
+                    pc=0x48820;
+                    run_48800(); return;
+                case 0x63038:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x63200:
+                    pc=0x63200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_63200() throws ExecutionException { /* 0x63200 - 0x63400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x63200:
+                    r2 = readPages[(r5+100)>>>12][((r5+100)>>>2)&0x3ff];
+                    r29 = r29 + -56;
+                    r2 = r2 & 8192;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r22;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r23;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r21;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    r19 = r5 + r0;
+                    r22 = r6 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63308;
+                        continue;
+                    }
+                    r2 = readPages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff];
+                    r20 = r4 + r0;
+                    r23 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r21 = r0 + -1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x632fc;
+                        continue;
+                    }
+                case 0x63258:
+                    r18 = readPages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff];
+                    r16 = readPages[(r23+0)>>>12][((r23+0)>>>2)&0x3ff];
+                    r18 = r18 >>> 2;
+                    r17 = r0 + r0;
+                    if(r18 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63288;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x632e4;
+                    continue;
+                case 0x63278:
+                    r17 = r17 + 1;
+                    r16 = r16 + 4;
+                    if(r18 == r17) {
+                        /* Next insn is delay slot */ 
+                        pc=0x632e0;
+                        continue;
+                    }
+                case 0x63288:
+                    r5 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r4 = r20 + r0;
+                    r6 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6329c;
+                    pc=0x65800;
+                    run_65800(); return;
+                case 0x6329c:
+                    if(r2 != r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63278;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                case 0x632a8:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r23 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r21 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    writePages[(r22+8)>>>12][((r22+8)>>>2)&0x3ff] = r0;
+                    writePages[(r22+4)>>>12][((r22+4)>>>2)&0x3ff] = r0;
+                    r22 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x632e0:
+                    r2 = readPages[(r22+8)>>>12][((r22+8)>>>2)&0x3ff];
+                case 0x632e4:
+                    r18 = r18 << 2;
+                    r2 = r2 - r18;
+                    writePages[(r22+8)>>>12][((r22+8)>>>2)&0x3ff] = r2;
+                    r23 = r23 + 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63258;
+                        continue;
+                    }
+                case 0x632fc:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x632a8;
+                    continue;
+                case 0x63308:
+                    /* Next insn is delay slot */ 
+                    r31=0x63310;
+                    pc=0x59c00;
+                    run_59c00(); return;
+                case 0x63310:
+                    /* Next insn is delay slot */ 
+                    pc=0x632a8;
+                    continue;
+                case 0x63400:
+                    pc=0x63400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_63400() throws ExecutionException { /* 0x63400 - 0x63600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x63400:
+                    r3 = readPages[(r6+8)>>>12][((r6+8)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63418;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x63418:
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = r0;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x63600:
+                    pc=0x63600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_63600() throws ExecutionException { /* 0x63600 - 0x63800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x63600:
+                    r29 = r29 + -1248;
+                    writePages[(r29+1236)>>>12][((r29+1236)>>>2)&0x3ff] = r23;
+                    writePages[(r29+1224)>>>12][((r29+1224)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1244)>>>12][((r29+1244)>>>2)&0x3ff] = r31;
+                    writePages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff] = r22;
+                    writePages[(r29+1228)>>>12][((r29+1228)>>>2)&0x3ff] = r21;
+                    writePages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff] = r17;
+                    writePages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff] = r16;
+                    r18 = r4 + r0;
+                    r23 = r5 + r0;
+                    r20 = r6 + r0;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r7;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63654;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6414c;
+                        run_64000(); return;
+                    }
+                case 0x63654:
+                    addr=r23+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r2 = r3 & 65535;
+                    r4 = r2 & 8192;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63688;
+                        continue;
+                    }
+                    r4 = readPages[(r23+100)>>>12][((r23+100)>>>2)&0x3ff];
+                    r2 = r0 + -8193;
+                    r3 = r3 | 8192;
+                    r2 = r4 & r2;
+                    writePages[(r23+100)>>>12][((r23+100)>>>2)&0x3ff] = r2;
+                    addr=r23+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r3 & 65535;
+                case 0x63688:
+                    r4 = r2 & 8;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63fd4;
+                        run_63e00(); return;
+                    }
+                    r4 = readPages[(r23+16)>>>12][((r23+16)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63fd4;
+                        run_63e00(); return;
+                    }
+                    r2 = r2 & 26;
+                    r4 = r0 + 10;
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64004;
+                        run_64000(); return;
+                    }
+                case 0x636b4:
+                    r3 = r29 + 1080;
+                    writePages[(r29+1160)>>>12][((r29+1160)>>>2)&0x3ff] = r3;
+                    r4 = readPages[(r29+1160)>>>12][((r29+1160)>>>2)&0x3ff];
+                    r3 = r29 + 1079;
+                    r21 = r29 + 16;
+                    r10 = 7 << 16;
+                    writePages[(r29+1164)>>>12][((r29+1164)>>>2)&0x3ff] = r3;
+                    r3 = r4 - r3;
+                    writePages[(r29+1192)>>>12][((r29+1192)>>>2)&0x3ff] = r3;
+                    writePages[(r29+1144)>>>12][((r29+1144)>>>2)&0x3ff] = r21;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1188)>>>12][((r29+1188)>>>2)&0x3ff] = r0;
+                    writePages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff] = r0;
+                    r22 = r10 + 4292;
+                    r3 = r21 + r0;
+                    writePages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff] = r18;
+                    writePages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff] = r23;
+                    r16 = r20 + r0;
+                case 0x63700:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64728;
+                        run_64600(); return;
+                    }
+                    r4 = r0 + 37;
+                    r17 = r16 + r0;
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63730;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x63798;
+                    continue;
+                case 0x63728:
+                    if(r2 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63744;
+                        continue;
+                    }
+                case 0x63730:
+                    r17 = r17 + 1;
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63728;
+                        continue;
+                    }
+                case 0x63744:
+                    r19 = r17 - r16;
+                    if(r19 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63798;
+                        continue;
+                    }
+                    r2 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r4 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r4 = r19 + r4;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r2;
+                    r2 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r16;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r4;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x637fc;
+                        continue;
+                    }
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64640;
+                        run_64600(); return;
+                    }
+                    r5 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r0;
+                    r5 = r5 + r19;
+                    r3 = r21 + r0;
+                    writePages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff] = r5;
+                case 0x63798:
+                    addr=r17+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x647a0;
+                        run_64600(); return;
+                    }
+                    r2 = r17 + 1;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r6 = r0 + r0;
+                    r30 = r0 + -1;
+                    r17 = r0 + r0;
+                    r23 = r0 + r0;
+                    r7 = r0 + 42;
+                case 0x637c4:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r16 = r2 + 1;
+                case 0x637cc:
+                    r2 = r4 + -32;
+                    r5 = (r2&0xffffffffL) < (89&0xffffffffL) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6457c;
+                        run_64400(); return;
+                    }
+                    r5 = 7 << 16;
+                    r2 = r2 << 2;
+                    r5 = r5 + 3920;
+                    r2 = r5 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x637fc:
+                    r3 = r3 + 8;
+                case 0x63800:
+                    pc=0x63800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_63800() throws ExecutionException { /* 0x63800 - 0x63a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x63800:
+                    r5 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                    r5 = r5 + r19;
+                    writePages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x63798;
+                    run_63600(); return;
+                case 0x63818:
+                    r23 = r23 | 16;
+                case 0x6381c:
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x63828:
+                    r23 = r23 | 16;
+                case 0x6382c:
+                    r2 = r23 & 16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63c68;
+                        run_63c00(); return;
+                    }
+                    r2 = r23 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63c68;
+                        run_63c00(); return;
+                    }
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r4 = r0 + 1;
+                    addr=r5+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r5 = r5 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x63884;
+                    continue;
+                case 0x63860:
+                    r23 = r23 | 16;
+                case 0x63864:
+                    r2 = r23 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x642e8;
+                        run_64200(); return;
+                    }
+                case 0x63870:
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                case 0x63884:
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = r30 + r0;
+                    r5 = r0 + r0;
+                case 0x63890:
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x638a0;
+                        continue;
+                    }
+                    r6 = r0 + -129;
+                    r23 = r23 & r6;
+                case 0x638a0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63d50;
+                        run_63c00(); return;
+                    }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63d50;
+                        run_63c00(); return;
+                    }
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64178;
+                        run_64000(); return;
+                    }
+                case 0x638b8:
+                    r18 = r29 + 1080;
+                case 0x638bc:
+                    r2 = r19 < r30 ? 1 : 0;
+                    writePages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff] = r19;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x638d0;
+                        continue;
+                    }
+                    writePages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff] = r30;
+                case 0x638d0:
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x638e8;
+                        continue;
+                    }
+                    r2 = readPages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff] = r2;
+                case 0x638e8:
+                    r15 = r23 & 2;
+                    if(r15 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63904;
+                        continue;
+                    }
+                    r4 = readPages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff];
+                    r4 = r4 + 2;
+                    writePages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff] = r4;
+                case 0x63904:
+                    r20 = r23 & 132;
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63cc4;
+                        run_63c00(); return;
+                    }
+                    r5 = readPages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff];
+                    r9 = r17 - r5;
+                    if(r9 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63cc4;
+                        run_63c00(); return;
+                    }
+                    r2 = r9 < 17 ? 1 : 0;
+                    r8 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64854;
+                        run_64800(); return;
+                    }
+                    writePages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff] = r16;
+                    r4 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    writePages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff] = r22;
+                    r25 = r0 + 16;
+                    writePages[(r29+1196)>>>12][((r29+1196)>>>2)&0x3ff] = r15;
+                    r16 = r9 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63970;
+                    continue;
+                case 0x63954:
+                    r7 = r4 + 2;
+                    r3 = r3 + 8;
+                    r4 = r2 + r0;
+                case 0x63960:
+                    r16 = r16 + -16;
+                    r2 = r16 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x639b8;
+                        continue;
+                    }
+                case 0x63970:
+                    r2 = r4 + 1;
+                    r8 = r8 + 16;
+                    r5 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r22;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r25;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r8;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r2;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63954;
+                        continue;
+                    }
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63c88;
+                        run_63c00(); return;
+                    }
+                    r16 = r16 + -16;
+                    r2 = r16 < 17 ? 1 : 0;
+                    r4 = r0 + r0;
+                    r7 = r0 + 1;
+                    r3 = r21 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63970;
+                        continue;
+                    }
+                case 0x639b8:
+                    r9 = r16 + r0;
+                    r15 = readPages[(r29+1196)>>>12][((r29+1196)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1200)>>>12][((r29+1200)>>>2)&0x3ff];
+                case 0x639c4:
+                    r2 = readPages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff];
+                    r5 = r9 + r8;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = r7 < 8 ? 1 : 0;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r9;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r7;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6415c;
+                        run_64000(); return;
+                    }
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r3 + 8;
+                    r4 = r7 + 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63ce0;
+                        run_63c00(); return;
+                    }
+                case 0x639fc:
+                    if(r15 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63a38;
+                        run_63a00(); return;
+                    }
+                case 0x63a00:
+                    pc=0x63a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_63a00() throws ExecutionException { /* 0x63a00 - 0x63c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x63a00:
+                    r2 = r29 + 1156;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 2;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r2;
+                    r5 = r5 + 2;
+                    r2 = r4 < 8 ? 1 : 0;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x640e0;
+                        run_64000(); return;
+                    }
+                    r7 = r4 + r0;
+                    r3 = r3 + 8;
+                    r4 = r4 + 1;
+                case 0x63a38:
+                    r2 = r0 + 128;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63ebc;
+                        run_63e00(); return;
+                    }
+                case 0x63a44:
+                    r20 = r30 - r19;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63b0c;
+                        continue;
+                    }
+                    r2 = r20 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64790;
+                        run_64600(); return;
+                    }
+                    r4 = 7 << 16;
+                    r8 = r4 + 4276;
+                    writePages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff] = r16;
+                    r30 = r0 + 16;
+                    r16 = r8 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63a94;
+                    continue;
+                case 0x63a78:
+                    r4 = r7 + 2;
+                    r3 = r3 + 8;
+                    r7 = r2 + r0;
+                case 0x63a84:
+                    r20 = r20 + -16;
+                    r2 = r20 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63adc;
+                        continue;
+                    }
+                case 0x63a94:
+                    r2 = r7 + 1;
+                    r5 = r5 + 16;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r16;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r30;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63a78;
+                        continue;
+                    }
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63d1c;
+                        run_63c00(); return;
+                    }
+                    r20 = r20 + -16;
+                    r2 = r20 < 17 ? 1 : 0;
+                    r7 = r0 + r0;
+                    r4 = r0 + 1;
+                    r3 = r21 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63a94;
+                        continue;
+                    }
+                case 0x63adc:
+                    r8 = r16 + r0;
+                    r16 = readPages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff];
+                case 0x63ae4:
+                    r5 = r5 + r20;
+                    r2 = r4 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r8;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63e80;
+                        run_63e00(); return;
+                    }
+                    r3 = r3 + 8;
+                    r4 = r4 + 1;
+                case 0x63b0c:
+                    r14 = r19 + r5;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r4;
+                    r4 = r4 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r18;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r14;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63ea4;
+                        run_63e00(); return;
+                    }
+                    if(r14 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64614;
+                        run_64600(); return;
+                    }
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r0;
+                    r3 = r21 + r0;
+                case 0x63b3c:
+                    r12 = r23 & 4;
+                    if(r12 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63c0c;
+                        run_63c00(); return;
+                    }
+                    r5 = readPages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff];
+                    r18 = r17 - r5;
+                    if(r18 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63c0c;
+                        run_63c00(); return;
+                    }
+                    r2 = r18 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x648a8;
+                        run_64800(); return;
+                    }
+                    r4 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    writePages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff] = r22;
+                    r19 = r0 + 16;
+                    r20 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r23 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x63ba0;
+                    continue;
+                case 0x63b84:
+                    r5 = r4 + 2;
+                    r3 = r3 + 8;
+                    r4 = r2 + r0;
+                case 0x63b90:
+                    r18 = r18 + -16;
+                    r2 = r18 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63be8;
+                        continue;
+                    }
+                case 0x63ba0:
+                    r2 = r4 + 1;
+                    r14 = r14 + 16;
+                    r5 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r22;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r14;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r2;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63b84;
+                        continue;
+                    }
+                    if(r14 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63e4c;
+                        run_63e00(); return;
+                    }
+                    r18 = r18 + -16;
+                    r2 = r18 < 17 ? 1 : 0;
+                    r4 = r0 + r0;
+                    r5 = r0 + 1;
+                    r3 = r21 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63ba0;
+                        continue;
+                    }
+                case 0x63be8:
+                    r2 = readPages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff];
+                    r14 = r14 + r18;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r5;
+                    r5 = r5 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r18;
+                case 0x63c00:
+                    pc=0x63c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_63c00() throws ExecutionException { /* 0x63c00 - 0x63e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x63c00:
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r14;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6451c;
+                        run_64400(); return;
+                    }
+                case 0x63c0c:
+                    r19 = readPages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff];
+                    r2 = r19 < r17 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63c24;
+                        continue;
+                    }
+                    r19 = r17 + r0;
+                case 0x63c24:
+                    r3 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                    r3 = r3 + r19;
+                    writePages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff] = r3;
+                    if(r14 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63c58;
+                        continue;
+                    }
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x63c50;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x63c50:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        continue;
+                    }
+                case 0x63c58:
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r0;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63700;
+                    run_63600(); return;
+                case 0x63c68:
+                    r4 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r4 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r4;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x63884;
+                    run_63800(); return;
+                case 0x63c88:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    writePages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff] = r25;
+                    /* Next insn is delay slot */ 
+                    r31=0x63ca0;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x63ca0:
+                    r25 = readPages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        continue;
+                    }
+                    r4 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r8 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r7 = r4 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63960;
+                    run_63800(); return;
+                case 0x63cc4:
+                    r7 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r4 = r7 + 1;
+                case 0x63cd0:
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x639fc;
+                        run_63800(); return;
+                    }
+                case 0x63ce0:
+                    r2 = r29 + 1158;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r2;
+                    r5 = r5 + 1;
+                    r2 = r4 < 8 ? 1 : 0;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x640c4;
+                        run_64000(); return;
+                    }
+                    r7 = r4 + r0;
+                    r3 = r3 + 8;
+                    r4 = r4 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x639fc;
+                    run_63800(); return;
+                case 0x63d1c:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x63d30;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x63d30:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        continue;
+                    }
+                    r7 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r4 = r7 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63a84;
+                    run_63a00(); return;
+                case 0x63d50:
+                    r6 = r0 + 1;
+                    if(r4 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x640fc;
+                        run_64000(); return;
+                    }
+                    r6 = r0 + 2;
+                    r18 = r29 + 1080;
+                    if(r4 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63da4;
+                        continue;
+                    }
+                    r6 = readPages[(r29+1188)>>>12][((r29+1188)>>>2)&0x3ff];
+                case 0x63d70:
+                    r4 = r2 & 15;
+                    r4 = r6 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r18 = r18 + -1;
+                    r2 = r2 >>> 4;
+                    addr=r18+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63d70;
+                        continue;
+                    }
+                case 0x63d90:
+                    r4 = readPages[(r29+1160)>>>12][((r29+1160)>>>2)&0x3ff];
+                    r19 = r4 - r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x638bc;
+                    run_63800(); return;
+                case 0x63da4:
+                    r4 = r2 & 7;
+                    r18 = r18 + -1;
+                    r4 = r4 + 48;
+                    r2 = r2 >>> 3;
+                    addr=r18+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63da4;
+                        continue;
+                    }
+                    r2 = r23 & 1;
+                    r6 = r18 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63de4;
+                        continue;
+                    }
+                    r2 = r0 + 48;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63d90;
+                        continue;
+                    }
+                    r18 = r18 + -1;
+                    addr=r6+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x63de4:
+                    r2 = readPages[(r29+1160)>>>12][((r29+1160)>>>2)&0x3ff];
+                    r19 = r2 - r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x638bc;
+                    run_63800(); return;
+                case 0x63df8:
+                    r23 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                case 0x63e00:
+                    pc=0x63e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_63e00() throws ExecutionException { /* 0x63e00 - 0x64000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x63e00:
+                    addr=r23+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63eb0;
+                        continue;
+                    }
+                    r2 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                case 0x63e18:
+                    r31 = readPages[(r29+1244)>>>12][((r29+1244)>>>2)&0x3ff];
+                    r30 = readPages[(r29+1240)>>>12][((r29+1240)>>>2)&0x3ff];
+                    r23 = readPages[(r29+1236)>>>12][((r29+1236)>>>2)&0x3ff];
+                    r22 = readPages[(r29+1232)>>>12][((r29+1232)>>>2)&0x3ff];
+                    r21 = readPages[(r29+1228)>>>12][((r29+1228)>>>2)&0x3ff];
+                    r20 = readPages[(r29+1224)>>>12][((r29+1224)>>>2)&0x3ff];
+                    r19 = readPages[(r29+1220)>>>12][((r29+1220)>>>2)&0x3ff];
+                    r18 = readPages[(r29+1216)>>>12][((r29+1216)>>>2)&0x3ff];
+                    r17 = readPages[(r29+1212)>>>12][((r29+1212)>>>2)&0x3ff];
+                    r16 = readPages[(r29+1208)>>>12][((r29+1208)>>>2)&0x3ff];
+                    r29 = r29 + 1248;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x63e4c:
+                    r4 = r20 + r0;
+                    r5 = r23 + r0;
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x63e60;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x63e60:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63e00;
+                        continue;
+                    }
+                    r4 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r14 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r5 = r4 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63b90;
+                    run_63a00(); return;
+                case 0x63e80:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x646f4;
+                        run_64600(); return;
+                    }
+                    r2 = r0 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r19;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r2;
+                    r14 = r19 + r0;
+                    r3 = r21 + r0;
+                case 0x63ea4:
+                    r3 = r3 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x63b3c;
+                    run_63a00(); return;
+                case 0x63eb0:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x63e18;
+                    continue;
+                case 0x63ebc:
+                    r2 = readPages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff];
+                    r20 = r17 - r2;
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63a44;
+                        run_63a00(); return;
+                    }
+                    r2 = r20 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x648d4;
+                        run_64800(); return;
+                    }
+                    r4 = 7 << 16;
+                    r8 = r4 + 4276;
+                    writePages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff] = r16;
+                    r9 = r0 + 16;
+                    r16 = r8 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63f14;
+                    continue;
+                case 0x63ef8:
+                    r6 = r7 + 2;
+                    r3 = r3 + 8;
+                    r7 = r2 + r0;
+                case 0x63f04:
+                    r20 = r20 + -16;
+                    r2 = r20 < 17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63f5c;
+                        continue;
+                    }
+                case 0x63f14:
+                    r2 = r7 + 1;
+                    r5 = r5 + 16;
+                    r4 = r2 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r16;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r9;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r2;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63ef8;
+                        continue;
+                    }
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63f98;
+                        continue;
+                    }
+                    r20 = r20 + -16;
+                    r2 = r20 < 17 ? 1 : 0;
+                    r7 = r0 + r0;
+                    r6 = r0 + 1;
+                    r3 = r21 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63f14;
+                        continue;
+                    }
+                case 0x63f5c:
+                    r8 = r16 + r0;
+                    r16 = readPages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff];
+                case 0x63f64:
+                    r5 = r5 + r20;
+                    r2 = r6 < 8 ? 1 : 0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r8;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r20;
+                    writePages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r6;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x646d8;
+                        run_64600(); return;
+                    }
+                    r3 = r3 + 8;
+                    r4 = r6 + 1;
+                    r7 = r6 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63a44;
+                    run_63a00(); return;
+                case 0x63f98:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    writePages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff] = r9;
+                    /* Next insn is delay slot */ 
+                    r31=0x63fb0;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x63fb0:
+                    r9 = readPages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r7 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r6 = r7 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63f04;
+                    continue;
+                case 0x63fd4:
+                    r4 = r18 + r0;
+                    r5 = r23 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x63fe4;
+                    pc=0x48600;
+                    run_48600(); return;
+                case 0x63fe4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63eb0;
+                        continue;
+                    }
+                    addr=r23+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r3 = tmp;
+                    r4 = r0 + 10;
+                    r2 = r3 & 65535;
+                    r2 = r2 & 26;
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x636b4;
+                        run_63600(); return;
+                    }
+                case 0x64000:
+                    pc=0x64000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_64000() throws ExecutionException { /* 0x64000 - 0x64200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x64000:
+                case 0x64004:
+                    addr=r23+14;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x636b4;
+                        run_63600(); return;
+                    }
+                    addr=r29+1054;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r23+28)>>>12][((r23+28)>>>2)&0x3ff];
+                    r4 = r0 + -3;
+                    writePages[(r29+1068)>>>12][((r29+1068)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r23+36)>>>12][((r23+36)>>>2)&0x3ff];
+                    r3 = r3 & r4;
+                    addr=r29+1052;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r3&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1076)>>>12][((r29+1076)>>>2)&0x3ff] = r2;
+                    r3 = readPages[(r23+100)>>>12][((r23+100)>>>2)&0x3ff];
+                    r2 = r29 + 16;
+                    r7 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    writePages[(r29+1040)>>>12][((r29+1040)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1056)>>>12][((r29+1056)>>>2)&0x3ff] = r2;
+                    r4 = r18 + r0;
+                    r2 = r0 + 1024;
+                    r5 = r29 + 1040;
+                    r6 = r20 + r0;
+                    writePages[(r29+1140)>>>12][((r29+1140)>>>2)&0x3ff] = r3;
+                    writePages[(r29+1048)>>>12][((r29+1048)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1060)>>>12][((r29+1060)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1064)>>>12][((r29+1064)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x64070;
+                    pc=0x63600;
+                    run_63600(); return;
+                case 0x64070:
+                    r21 = r2 + r0;
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64094;
+                        continue;
+                    }
+                    r4 = r18 + r0;
+                    r5 = r29 + 1040;
+                    /* Next insn is delay slot */ 
+                    r31=0x6408c;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x6408c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64920;
+                        run_64800(); return;
+                    }
+                case 0x64094:
+                    addr=r29+1052;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x640b8;
+                        continue;
+                    }
+                    addr=r23+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 64;
+                    addr=r23+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x640b8:
+                    r2 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63e18;
+                    run_63e00(); return;
+                case 0x640c4:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64668;
+                        run_64600(); return;
+                    }
+                    r7 = r0 + r0;
+                    r4 = r0 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x639fc;
+                    run_63800(); return;
+                case 0x640e0:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x646a4;
+                        run_64600(); return;
+                    }
+                    r7 = r0 + r0;
+                    r4 = r0 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63a38;
+                    run_63a00(); return;
+                case 0x640fc:
+                    r4 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64554;
+                        run_64400(); return;
+                    }
+                    r18 = r29 + 1080;
+                    r4 = r0 + 10;
+                case 0x64110:
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r4!=0) {
+                        hi = (int)((r2 & 0xffffffffL) % (r4 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r4 & 0xffffffffL));
+                        }
+                        pc=0x6411c;
+                        continue;
+                    }
+                    if(r4!=0) {
+                    hi = (int)((r2 & 0xffffffffL) % (r4 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r4 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x6411c:
+                    r18 = r18 + -1;
+                    r6 = hi;
+                    r6 = r6 + 48;
+                    addr=r18+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = lo;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64110;
+                        continue;
+                    }
+                    r2 = readPages[(r29+1160)>>>12][((r29+1160)>>>2)&0x3ff];
+                    r19 = r2 - r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x638bc;
+                    run_63800(); return;
+                case 0x6414c:
+                    /* Next insn is delay slot */ 
+                    r31=0x64154;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x64154:
+                    /* Next insn is delay slot */ 
+                    pc=0x63654;
+                    run_63600(); return;
+                case 0x6415c:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x645ac;
+                        run_64400(); return;
+                    }
+                    r7 = r0 + r0;
+                    r4 = r0 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63cd0;
+                    run_63c00(); return;
+                case 0x64178:
+                    r2 = r23 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x638b8;
+                        run_63800(); return;
+                    }
+                    r2 = r0 + 48;
+                    addr=r29+1079;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = readPages[(r29+1192)>>>12][((r29+1192)>>>2)&0x3ff];
+                    r18 = r29 + 1079;
+                    /* Next insn is delay slot */ 
+                    pc=0x638bc;
+                    run_63800(); return;
+                case 0x6419c:
+                    r4 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r17 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r4 + 4;
+                    if(r17 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6456c;
+                        run_64400(); return;
+                    }
+                    r17 = r0 - r17;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r2;
+                case 0x641bc:
+                    r23 = r23 | 4;
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x641cc:
+                    r6 = r0 + 43;
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x641dc:
+                    r2 = r23 & 16;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x645e8;
+                        run_64400(); return;
+                    }
+                    r12 = r23 & 64;
+                    if(r12 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x645e8;
+                        run_64400(); return;
+                    }
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r4 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                case 0x64200:
+                    pc=0x64200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_64200() throws ExecutionException { /* 0x64200 - 0x64400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x64200:
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r4&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x63700;
+                    run_63600(); return;
+                case 0x64218:
+                    r2 = 7 << 16;
+                    r2 = r2 + 248;
+                    writePages[(r29+1188)>>>12][((r29+1188)>>>2)&0x3ff] = r2;
+                    r2 = r23 & 16;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x643c8;
+                        continue;
+                    }
+                case 0x64234:
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                case 0x64248:
+                    r5 = r23 & 1;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64608;
+                        run_64600(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64608;
+                        run_64600(); return;
+                    }
+                    r5 = r0 + 48;
+                    addr=r29+1157;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+1156;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r23 = r23 | 2;
+                    r4 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x63884;
+                    run_63800(); return;
+                case 0x64278:
+                    r23 = r23 | 64;
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x64288:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r5 = r16 + 1;
+                    if(r4 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x648f4;
+                        run_64800(); return;
+                    }
+                    r2 = r4 + -48;
+                    r8 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    r30 = r0 + r0;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x642dc;
+                        continue;
+                    }
+                case 0x642ac:
+                    r4 = r30 << 1;
+                    r5 = r5 + 1;
+                    r30 = r30 << 3;
+                    r30 = r4 + r30;
+                    addr=r5+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r30 = r2 + r30;
+                    r2 = r4 + -48;
+                    r8 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r8 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x642ac;
+                        continue;
+                    }
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64780;
+                        run_64600(); return;
+                    }
+                case 0x642dc:
+                    r16 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637cc;
+                    run_63600(); return;
+                case 0x642e8:
+                    r2 = r23 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63870;
+                        run_63800(); return;
+                    }
+                    r4 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    addr=r4+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r4 = r4 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r4;
+                    r4 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63884;
+                    run_63800(); return;
+                case 0x64314:
+                    r23 = r23 | 128;
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x64324:
+                    r17 = r0 + r0;
+                    r2 = r4 + -48;
+                case 0x6432c:
+                    r4 = r17 << 1;
+                    r16 = r16 + 1;
+                    r17 = r17 << 3;
+                    r17 = r4 + r17;
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r17 = r17 + r2;
+                    r2 = r4 + -48;
+                    r5 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6432c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x637cc;
+                    run_63600(); return;
+                case 0x6435c:
+                    r23 = r23 | 16;
+                    r2 = r23 & 16;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64430;
+                        run_64400(); return;
+                    }
+                case 0x64370:
+                    r2 = r23 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64430;
+                        run_64400(); return;
+                    }
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    addr=r5+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r5 = r5 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                case 0x64390:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64734;
+                        run_64600(); return;
+                    }
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r19 = r30 + r0;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x63890;
+                    run_63800(); return;
+                case 0x643ac:
+                    r2 = 7 << 16;
+                    r2 = r2 + 228;
+                    writePages[(r29+1188)>>>12][((r29+1188)>>>2)&0x3ff] = r2;
+                    r2 = r23 & 16;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64234;
+                        continue;
+                    }
+                case 0x643c8:
+                    r2 = r23 & 64;
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64754;
+                        run_64600(); return;
+                    }
+                    addr=r5+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r5 = r5 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x64248;
+                    continue;
+                case 0x643ec:
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    addr=r29+1040;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x64400:
+                    pc=0x64400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_64400() throws ExecutionException { /* 0x64400 - 0x64600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x64400:
+                    r2 = r0 + 1;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                    writePages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff] = r2;
+                    r19 = r0 + 1;
+                    r18 = r29 + 1040;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x638e8;
+                    run_63800(); return;
+                case 0x64420:
+                    r2 = r23 & 16;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64370;
+                        run_64200(); return;
+                    }
+                case 0x64430:
+                    r4 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r4 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x64390;
+                    run_64200(); return;
+                case 0x6444c:
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6381c;
+                        run_63800(); return;
+                    }
+                    r6 = r0 + 32;
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x64464:
+                    r23 = r23 | 1;
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x64474:
+                    r2 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r18 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r20 = r2 + 4;
+                    if(r18 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64868;
+                        run_64800(); return;
+                    }
+                    r4 = r18 + r0;
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x647f8;
+                        run_64600(); return;
+                    }
+                    r5 = r0 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x644ac;
+                    pc=0x5b400;
+                    run_5b400(); return;
+                case 0x644ac:
+                    r3 = readPages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x648bc;
+                        run_64800(); return;
+                    }
+                    r19 = r2 - r18;
+                    r2 = r30 < r19 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64774;
+                        run_64600(); return;
+                    }
+                case 0x644c8:
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r20;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x638bc;
+                    run_63800(); return;
+                case 0x644dc:
+                    r4 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r2 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r4 = r0 + 48;
+                    addr=r29+1156;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = r0 + 120;
+                    addr=r29+1157;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = 7 << 16;
+                    r4 = r4 + 248;
+                    r5 = r5 + 4;
+                    writePages[(r29+1188)>>>12][((r29+1188)>>>2)&0x3ff] = r4;
+                    r23 = r23 | 2;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                    r4 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x63884;
+                    run_63800(); return;
+                case 0x6451c:
+                    if(r14 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x647d0;
+                        run_64600(); return;
+                    }
+                    r19 = readPages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff];
+                    r2 = r19 < r17 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64768;
+                        run_64600(); return;
+                    }
+                case 0x64538:
+                    r3 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                    writePages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff] = r0;
+                    r3 = r3 + r19;
+                    writePages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff] = r3;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63700;
+                    run_63600(); return;
+                case 0x64554:
+                    r2 = r2 + 48;
+                    addr=r29+1079;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r19 = readPages[(r29+1192)>>>12][((r29+1192)>>>2)&0x3ff];
+                    r18 = r29 + 1079;
+                    /* Next insn is delay slot */ 
+                    pc=0x638bc;
+                    run_63800(); return;
+                case 0x6456c:
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r2;
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x6457c:
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x647a0;
+                        run_64600(); return;
+                    }
+                    r5 = r0 + 1;
+                    addr=r29+1040;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff] = r5;
+                    r19 = r0 + 1;
+                    r18 = r29 + 1040;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x638e8;
+                    run_63800(); return;
+                case 0x645ac:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    writePages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff] = r15;
+                    /* Next insn is delay slot */ 
+                    r31=0x645c4;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x645c4:
+                    r15 = readPages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r7 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r4 = r7 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63cd0;
+                    run_63c00(); return;
+                case 0x645e8:
+                    r5 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r4 = readPages[(r29+1180)>>>12][((r29+1180)>>>2)&0x3ff];
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                case 0x64600:
+                    pc=0x64600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_64600() throws ExecutionException { /* 0x64600 - 0x64800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x64600:
+                    /* Next insn is delay slot */ 
+                    pc=0x63700;
+                    run_63600(); return;
+                case 0x64608:
+                    r4 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x63884;
+                    run_63800(); return;
+                case 0x64614:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x64628;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x64628:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r14 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63b3c;
+                    run_63a00(); return;
+                case 0x64640:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x64654;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x64654:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63800;
+                    run_63800(); return;
+                case 0x64668:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    writePages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff] = r15;
+                    /* Next insn is delay slot */ 
+                    r31=0x64680;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x64680:
+                    r15 = readPages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r7 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r4 = r7 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x639fc;
+                    run_63800(); return;
+                case 0x646a4:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x646b8;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x646b8:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r7 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r4 = r7 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63a38;
+                    run_63a00(); return;
+                case 0x646d8:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64820;
+                        run_64800(); return;
+                    }
+                    r7 = r0 + r0;
+                    r4 = r0 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63a44;
+                    run_63a00(); return;
+                case 0x646f4:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x64708;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x64708:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r4 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63b0c;
+                    run_63a00(); return;
+                case 0x64728:
+                    r17 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63798;
+                    run_63600(); return;
+                case 0x64734:
+                    r4 = r0 + 45;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 - r2;
+                    r19 = r30 + r0;
+                    r5 = r0 + 45;
+                    r4 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x63890;
+                    run_63800(); return;
+                case 0x64754:
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r5 = r5 + 4;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x64248;
+                    run_64200(); return;
+                case 0x64768:
+                    r19 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x64538;
+                    run_64400(); return;
+                case 0x64774:
+                    r19 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x644c8;
+                    run_64400(); return;
+                case 0x64780:
+                    r30 = r0 + -1;
+                    r16 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637cc;
+                    run_63600(); return;
+                case 0x64790:
+                    r2 = 7 << 16;
+                    r8 = r2 + 4276;
+                    /* Next insn is delay slot */ 
+                    pc=0x63ae4;
+                    run_63a00(); return;
+                case 0x647a0:
+                    r2 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r18 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r23 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63e00;
+                        run_63e00(); return;
+                    }
+                    r4 = r18 + r0;
+                    r5 = r23 + r0;
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x647c8;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x647c8:
+                    /* Next insn is delay slot */ 
+                    pc=0x63e00;
+                    run_63e00(); return;
+                case 0x647d0:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x647e4;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x647e4:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r14 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x63c0c;
+                    run_63c00(); return;
+                case 0x647f8:
+                    writePages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    r31=0x64804;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x64800:
+                    pc=0x64800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_64800() throws ExecutionException { /* 0x64800 - 0x64a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x64800:
+                case 0x64804:
+                    r19 = r2 + r0;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r20;
+                    r30 = r0 + r0;
+                    r3 = readPages[(r29+1204)>>>12][((r29+1204)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x638bc;
+                    run_63800(); return;
+                case 0x64820:
+                    r4 = readPages[(r29+1176)>>>12][((r29+1176)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1172)>>>12][((r29+1172)>>>2)&0x3ff];
+                    r6 = r29 + 1144;
+                    /* Next insn is delay slot */ 
+                    r31=0x64834;
+                    pc=0x63200;
+                    run_63200(); return;
+                case 0x64834:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x63df8;
+                        run_63c00(); return;
+                    }
+                    r7 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    r5 = readPages[(r29+1152)>>>12][((r29+1152)>>>2)&0x3ff];
+                    r4 = r7 + 1;
+                    r3 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63a44;
+                    run_63a00(); return;
+                case 0x64854:
+                    r7 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    writePages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff] = r22;
+                    r7 = r7 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x639c4;
+                    run_63800(); return;
+                case 0x64868:
+                    r2 = (r30&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r13 = r30 + r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6487c;
+                        continue;
+                    }
+                    r13 = r0 + 6;
+                case 0x6487c:
+                    r19 = r13 + r0;
+                    r2 = r13 + r0;
+                    if(r13 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x648e8;
+                        continue;
+                    }
+                case 0x6488c:
+                    r10 = 7 << 16;
+                    writePages[(r29+1168)>>>12][((r29+1168)>>>2)&0x3ff] = r2;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r20;
+                    r18 = r10 + 268;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x638e8;
+                    run_63800(); return;
+                case 0x648a8:
+                    r5 = readPages[(r29+1148)>>>12][((r29+1148)>>>2)&0x3ff];
+                    writePages[(r29+1184)>>>12][((r29+1184)>>>2)&0x3ff] = r22;
+                    r5 = r5 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x63be8;
+                    run_63a00(); return;
+                case 0x648bc:
+                    r19 = r30 + r0;
+                    addr=r29+1158;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r20;
+                    r30 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x638bc;
+                    run_63800(); return;
+                case 0x648d4:
+                    r2 = 7 << 16;
+                    r6 = r4 + r0;
+                    r8 = r2 + 4276;
+                    /* Next insn is delay slot */ 
+                    pc=0x63f64;
+                    run_63e00(); return;
+                case 0x648e8:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6488c;
+                    continue;
+                case 0x648f4:
+                    r4 = readPages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff];
+                    r16 = r5 + r0;
+                    r30 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r2 = r4 + 4;
+                    if(r30 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6456c;
+                        run_64400(); return;
+                    }
+                    writePages[(r29+1260)>>>12][((r29+1260)>>>2)&0x3ff] = r2;
+                    r30 = r0 + -1;
+                    r2 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x637c4;
+                    run_63600(); return;
+                case 0x64920:
+                    r21 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x64094;
+                    run_64000(); return;
+                case 0x64a00:
+                    pc=0x64a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_64a00() throws ExecutionException { /* 0x64a00 - 0x64c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x64a00:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x63600;
+                    run_63600(); return;
+                case 0x64c00:
+                    pc=0x64c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_64c00() throws ExecutionException { /* 0x64c00 - 0x64e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x64c00:
+                    r29 = r29 + -136;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r17;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r16;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r31;
+                    r17 = r4 + r0;
+                    r16 = r6 + r0;
+                    if(r6 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64ce4;
+                        continue;
+                    }
+                    r2 = r0 + 520;
+                    addr=r29+28;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r5;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64c9c;
+                        continue;
+                    }
+                    r2 = r0 + r0;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r4 = r17 + r0;
+                    r2 = r0 + -1;
+                    r5 = r29 + 16;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x64c64;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x64c64:
+                    r3 = r2 < -1 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64cd4;
+                        continue;
+                    }
+                case 0x64c70:
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64c84;
+                        continue;
+                    }
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x64c84:
+                    r31 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r17 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    r16 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r29 = r29 + 136;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x64c9c:
+                    r2 = r6 + -1;
+                    r6 = r7 + r0;
+                    r7 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r4 = r17 + r0;
+                    r2 = r0 + -1;
+                    r5 = r29 + 16;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x64cc8;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x64cc8:
+                    r3 = r2 < -1 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x64c70;
+                        continue;
+                    }
+                case 0x64cd4:
+                    r3 = r0 + 139;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x64c70;
+                    continue;
+                case 0x64ce4:
+                    r2 = r0 + 139;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x64c84;
+                    continue;
+                case 0x64e00:
+                    pc=0x64e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_64e00() throws ExecutionException { /* 0x64e00 - 0x65000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x64e00:
+                    r29 = r29 + -32;
+                    r8 = r4 + r0;
+                    r3 = r5 + r0;
+                    r2 = r6 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r5 = r8 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r7;
+                    r6 = r3 + r0;
+                    r7 = r2 + r0;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x64e30;
+                    pc=0x64c00;
+                    run_64c00(); return;
+                case 0x64e30:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x65000:
+                    pc=0x65000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_65000() throws ExecutionException { /* 0x65000 - 0x65200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x65000:
+                    r29 = r29 + -128;
+                    r2 = r0 + 520;
+                    addr=r29+28;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = 32767 << 16;
+                    r2 = r2 | 65535;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r5;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r2;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    r5 = r29 + 16;
+                    r2 = r0 + -1;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r31;
+                    addr=r29+30;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    r31=0x6503c;
+                    pc=0x43800;
+                    run_43800(); return;
+                case 0x6503c:
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    r29 = r29 + 128;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x65200:
+                    pc=0x65200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_65200() throws ExecutionException { /* 0x65200 - 0x65400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x65200:
+                    r3 = r4 + r0;
+                    r2 = r5 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r7 = r6 + r0;
+                    r5 = r3 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x65000;
+                    run_65000(); return;
+                case 0x65400:
+                    pc=0x65400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_65400() throws ExecutionException { /* 0x65400 - 0x65600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x65400:
+                    r29 = r29 + -88;
+                    r5 = r29 + 16;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r31;
+                    /* Next insn is delay slot */ 
+                    r31=0x65414;
+                    pc=0x62e00;
+                    run_62e00(); return;
+                case 0x65414:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65468;
+                        continue;
+                    }
+                    r3 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r2 = r0 + 8192;
+                    r3 = r3 & 61440;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65454;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x65438;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x65438:
+                    r3 = r0 + 25;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                case 0x65444:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x65454:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x65468:
+                    /* Next insn is delay slot */ 
+                    r31=0x65470;
+                    pc=0x38c00;
+                    run_38c00(); return;
+                case 0x65470:
+                    r3 = r0 + 9;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x65444;
+                    continue;
+                case 0x65600:
+                    pc=0x65600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_65600() throws ExecutionException { /* 0x65600 - 0x65800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x65600:
+                    { long hilo = (long)(r5) * ((long)r6); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r29 = r29 + -48;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r17;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r17 = r4 + r0;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r19;
+                    r5 = lo;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x65634;
+                    pc=0x3f600;
+                    run_3f600(); return;
+                case 0x65634:
+                    r2 = 7 << 16;
+                    r18 = readPages[(r2+11112)>>>12][((r2+11112)>>>2)&0x3ff];
+                    r5 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r20 = readPages[(r18+4)>>>12][((r18+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x65650;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x65650:
+                    r16 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6577c;
+                        continue;
+                    }
+                    r19 = readPages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff];
+                    r3 = r16 + -8;
+                    r2 = r0 + -4;
+                    r19 = r19 & r2;
+                    if(r18 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6574c;
+                        continue;
+                    }
+                case 0x65674:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x65680;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x65680:
+                    r6 = r19 + -4;
+                    r2 = (r6&0xffffffffL) < (37&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65708;
+                        continue;
+                    }
+                    r2 = (r6&0xffffffffL) < (20&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x656d4;
+                        continue;
+                    }
+                    r2 = r16 + r0;
+                case 0x656a0:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    writePages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff] = r0;
+                    writePages[(r2+8)>>>12][((r2+8)>>>2)&0x3ff] = r0;
+                    r2 = r16 + r0;
+                case 0x656b0:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x656d4:
+                    r2 = (r6&0xffffffffL) < (28&0xffffffffL) ? 1 : 0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65740;
+                        continue;
+                    }
+                    r2 = r0 + 36;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    writePages[(r16+12)>>>12][((r16+12)>>>2)&0x3ff] = r0;
+                    if(r6 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65768;
+                        continue;
+                    }
+                    r2 = r16 + 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x656a0;
+                    continue;
+                case 0x65708:
+                    r4 = r16 + r0;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x65718;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x65718:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r16 + r0;
+                    r20 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r19 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r18 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r17 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x65740:
+                    r2 = r16 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=0x656a0;
+                    continue;
+                case 0x6574c:
+                    r2 = r20 & r2;
+                    r3 = ((r2 & 0xffffffffL) < (r19 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65674;
+                        continue;
+                    }
+                    r19 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x65674;
+                    continue;
+                case 0x65768:
+                    writePages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff] = r0;
+                    r2 = r16 + 24;
+                    writePages[(r16+20)>>>12][((r16+20)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x656a0;
+                    continue;
+                case 0x6577c:
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x65788;
+                    pc=0x3f800;
+                    run_3f800(); return;
+                case 0x65788:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x656b0;
+                    continue;
+                case 0x65800:
+                    pc=0x65800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_65800() throws ExecutionException { /* 0x65800 - 0x65a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x65800:
+                    addr=r6+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -56;
+                    r3 = r2 & 8192;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    r19 = r4 + r0;
+                    r18 = r5 + r0;
+                    r16 = r6 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65854;
+                        continue;
+                    }
+                    r2 = r2 | 8192;
+                    addr=r6+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r6+100)>>>12][((r6+100)>>>2)&0x3ff];
+                    r2 = r2 | 8192;
+                    writePages[(r6+100)>>>12][((r6+100)>>>2)&0x3ff] = r2;
+                case 0x65854:
+                    /* Next insn is delay slot */ 
+                    r31=0x6585c;
+                    pc=0x5a800;
+                    run_5a800(); return;
+                case 0x6585c:
+                    r3 = r0 + 1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x659c4;
+                        continue;
+                    }
+                case 0x65868:
+                    r4 = r19 + r0;
+                    r5 = r29 + 16;
+                    r6 = r18 + r0;
+                    r7 = r16 + 92;
+                    /* Next insn is delay slot */ 
+                    r31=0x65880;
+                    pc=0x6aa00;
+                    run_6aa00(); return;
+                case 0x65880:
+                    r20 = r2 + r0;
+                    r2 = r0 + -1;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65958;
+                        continue;
+                    }
+                    if(r20 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6594c;
+                        continue;
+                    }
+                    addr=r29+16;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                case 0x6589c:
+                    r17 = r0 + r0;
+                    r21 = r0 + 10;
+                    /* Next insn is delay slot */ 
+                    pc=0x658e4;
+                    continue;
+                case 0x658ac:
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                case 0x658c8:
+                    r17 = r17 + 1;
+                    r3 = ((r17 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6594c;
+                        continue;
+                    }
+                case 0x658d8:
+                    r2 = r29 + 16;
+                    r3 = r2 + r17;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                case 0x658e4:
+                    r3 = readPages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r3;
+                    if(r3 >= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x658ac;
+                        continue;
+                    }
+                    r2 = readPages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff];
+                    r3 = r3 < r2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65994;
+                        continue;
+                    }
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    if(r3 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x659ec;
+                        continue;
+                    }
+                    r17 = r17 + 1;
+                    r2 = r2 + 1;
+                    r3 = ((r17 & 0xffffffffL) < (r20 & 0xffffffffL)) ? 1 : 0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x658d8;
+                        continue;
+                    }
+                case 0x6594c:
+                    r2 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6596c;
+                    continue;
+                case 0x65958:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 64;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -1;
+                case 0x6596c:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r21 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r20 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x65994:
+                    r4 = r19 + r0;
+                    r5 = r5 & 255;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x659a8;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x659a8:
+                    r2 = r2 + 1;
+                    r2 = (r2&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                case 0x659b0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x658c8;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6596c;
+                    continue;
+                case 0x659c4:
+                    r2 = r18 + -1;
+                    r2 = (r2&0xffffffffL) < (255&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65868;
+                        continue;
+                    }
+                    r5 = r18 << 24;
+                    r5 = r5 >> 24;
+                    addr=r29+16;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r20 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6589c;
+                    continue;
+                case 0x659ec:
+                    r4 = r19 + r0;
+                    r5 = r0 + 10;
+                    r6 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x65a00;
+                    pc=0x48200;
+                    run_48200(); return;
+                case 0x65a00:
+                    pc=0x65a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_65a00() throws ExecutionException { /* 0x65a00 - 0x65c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x65a00:
+                    r2 = r2 + 1;
+                    r2 = (r2&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    /* Next insn is delay slot */ 
+                    pc=0x659b0;
+                    run_65800(); return;
+                case 0x65c00:
+                    pc=0x65c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_65c00() throws ExecutionException { /* 0x65c00 - 0x65e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x65c00:
+                    r29 = r29 + -32;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    r16 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    r6 = r5 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65c5c;
+                        continue;
+                    }
+                    r3 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65c44;
+                        continue;
+                    }
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x65c3c;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x65c3c:
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                case 0x65c44:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x65800;
+                    run_65800(); return;
+                case 0x65c5c:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r5 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x65800;
+                    run_65800(); return;
+                case 0x65e00:
+                    pc=0x65e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_65e00() throws ExecutionException { /* 0x65e00 - 0x66000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x65e00:
+                    r2 = (r4&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x65e30;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r4 = r2 + r4;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 8;
+                    r2 = r2 & 255;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x65e30:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x66000:
+                    pc=0x66000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_66000() throws ExecutionException { /* 0x66000 - 0x66200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x66000:
+                    r29 = r29 + -56;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r18;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r17;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    r17 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r18 = readPages[(r28+-30952)>>>12][((r28+-30952)>>>2)&0x3ff];
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66094;
+                        continue;
+                    }
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r5;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r6;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x6603c;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x6603c:
+                    r5 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r6 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r7 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r4 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r18;
+                    r31=0x6605c;
+                    return;
+                case 0x6605c:
+                    r3 = r0 + -1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66078;
+                        continue;
+                    }
+                    r2 = r0 + 138;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                case 0x66078:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r18 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r17 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x66094:
+                    /* Next insn is delay slot */ 
+                    r31=0x6609c;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x6609c:
+                    r6 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r4 = r16 + r0;
+                    r5 = r0 + r0;
+                    r6 = r6 + -12264;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r18;
+                    r31=0x660c0;
+                    return;
+                case 0x660c0:
+                    /* Next insn is delay slot */ 
+                    pc=0x6605c;
+                    continue;
+                case 0x66200:
+                    pc=0x66200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_66200() throws ExecutionException { /* 0x66200 - 0x66400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x66200:
+                    r29 = r29 + -56;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r17;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r21;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r20;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r19;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r18;
+                    r16 = r5 + r0;
+                    r17 = r7 + r0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x662b0;
+                        continue;
+                    }
+                    r21 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r19 = r4 + r0;
+                    r18 = r6 + r0;
+                    r20 = readPages[(r28+-30952)>>>12][((r28+-30952)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x66248;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x66248:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r4 = r21 + r0;
+                    r5 = r19 + r0;
+                    r6 = r16 + r0;
+                    r7 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r20;
+                    r31=0x66268;
+                    return;
+                case 0x66268:
+                    r3 = r0 + -1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66288;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r3 = r0 + 138;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r0;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + -1;
+                case 0x66288:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r21 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r20 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r19 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r18 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r17 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r16 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x662b0:
+                    r18 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30952)>>>12][((r28+-30952)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x662c0;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x662c0:
+                    r6 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    r4 = r18 + r0;
+                    r5 = r0 + r0;
+                    r6 = r6 + -12264;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r16;
+                    r31=0x662e4;
+                    return;
+                case 0x662e4:
+                    /* Next insn is delay slot */ 
+                    pc=0x66268;
+                    continue;
+                case 0x66400:
+                    pc=0x66400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_66400() throws ExecutionException { /* 0x66400 - 0x66600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x66400:
+                    r29 = r29 + -8;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66440;
+                        continue;
+                    }
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6644c;
+                        continue;
+                    }
+                case 0x66414:
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6645c;
+                        continue;
+                    }
+                    addr=r6+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    writePages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff] = r2;
+                    addr=r6+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = ((r0 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                case 0x66434:
+                    r29 = r29 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x66440:
+                    r5 = r29 + r0;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66414;
+                        continue;
+                    }
+                case 0x6644c:
+                    r2 = r0 + r0;
+                    r29 = r29 + 8;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6645c:
+                    r2 = r0 + -2;
+                    /* Next insn is delay slot */ 
+                    pc=0x66434;
+                    continue;
+                case 0x66600:
+                    pc=0x66600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_66600() throws ExecutionException { /* 0x66600 - 0x66800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x66600:
+                    r29 = r29 + -48;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r4;
+                    r16 = readPages[(r28+-30952)>>>12][((r28+-30952)>>>2)&0x3ff];
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r6;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x66628;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x66628:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r6 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r7 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=r16;
+                    r31=0x6664c;
+                    return;
+                case 0x6664c:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x66800:
+                    pc=0x66800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_66800() throws ExecutionException { /* 0x66800 - 0x66a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x66800:
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r2 = r0 + 94;
+                    if(r8 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x668e8;
+                        continue;
+                    }
+                    r2 = r5 + 1;
+                    r7 = r0 + r0;
+                    r9 = r0 + r0;
+                case 0x6681c:
+                    r3 = r0 + r0;
+                    r6 = r0 + 256;
+                case 0x66824:
+                    r5 = r4 + r3;
+                    r3 = r3 + 1;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r7&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r3 != r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66824;
+                        continue;
+                    }
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66890;
+                        continue;
+                    }
+                    r5 = r0 + 1;
+                    r5 = r5 - r9;
+                    r10 = r0 + 45;
+                    r9 = r0 + 93;
+                case 0x66850:
+                    r3 = r4 + r8;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x66858:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r7 = r2 + 1;
+                    if(r3 == r10) {
+                        /* Next insn is delay slot */ 
+                        pc=0x668a8;
+                        continue;
+                    }
+                    if(r3 == r9) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6689c;
+                        continue;
+                    }
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66888;
+                        continue;
+                    }
+                    r8 = r3 + r0;
+                    r2 = r7 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x66850;
+                    continue;
+                case 0x66888:
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x66890:
+                    r2 = r2 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6689c:
+                    r2 = r7 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x668a8:
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    if(r6 == r9) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66900;
+                        continue;
+                    }
+                    r3 = r6 < r8 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66900;
+                        continue;
+                    }
+                    r2 = r2 + 2;
+                case 0x668c8:
+                    r8 = r8 + 1;
+                    r3 = r4 + r8;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r5&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r8 < r6 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x668c8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x66858;
+                    continue;
+                case 0x668e8:
+                    r2 = r5 + 2;
+                    addr=r5+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r7 = r0 + 1;
+                    r9 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6681c;
+                    continue;
+                case 0x66900:
+                    r8 = r0 + 45;
+                    r2 = r7 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x66850;
+                    continue;
+                case 0x66a00:
+                    pc=0x66a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_66a00() throws ExecutionException { /* 0x66a00 - 0x66c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x66a00:
+                    f0 = readPages[(r28+-30948)>>>12][((r28+-30948)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x66c00:
+                    pc=0x66c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_66c00() throws ExecutionException { /* 0x66c00 - 0x66e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x66c00:
+                    r29 = r29 + -216;
+                    writePages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff] = r22;
+                    writePages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff] = r18;
+                    writePages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff] = r16;
+                    writePages[(r29+164)>>>12][((r29+164)>>>2)&0x3ff] = r31;
+                    writePages[(r29+160)>>>12][((r29+160)>>>2)&0x3ff] = r30;
+                    writePages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff] = r23;
+                    writePages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff] = r21;
+                    writePages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff] = r20;
+                    writePages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff] = r19;
+                    writePages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff] = r17;
+                    writePages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff] = f30;
+                    writePages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff] = f31;
+                    writePages[(r29+204)>>>12][((r29+204)>>>2)&0x3ff] = f28;
+                    writePages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff] = f29;
+                    writePages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff] = f26;
+                    writePages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff] = f27;
+                    writePages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff] = f24;
+                    writePages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff] = f25;
+                    writePages[(r29+180)>>>12][((r29+180)>>>2)&0x3ff] = f22;
+                    writePages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff] = f23;
+                    writePages[(r29+172)>>>12][((r29+172)>>>2)&0x3ff] = f20;
+                    writePages[(r29+168)>>>12][((r29+168)>>>2)&0x3ff] = f21;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r5;
+                    r16 = r5 + r0;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    r18 = r4 + r0;
+                    r2 = r21 & 255;
+                    r4 = 7 << 16;
+                    r3 = (r2&0xffffffffL) < (46&0xffffffffL) ? 1 : 0;
+                    r22 = r5 + r0;
+                    writePages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff] = r6;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r0;
+                    r4 = r4 + 4324;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67000;
+                        run_67000(); return;
+                    }
+                case 0x66c94:
+                    r2 = r2 << 2;
+                    r2 = r4 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x66cac:
+                    r7 = r0 + r0;
+                    r3 = r0 + r0;
+                    r9 = r0 + 1;
+                case 0x66cb8:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67160;
+                        run_67000(); return;
+                    }
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67160;
+                        run_67000(); return;
+                    }
+                case 0x66cc8:
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r0;
+                case 0x66cd8:
+                    r3 = readPages[(r29+224)>>>12][((r29+224)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66cf4;
+                        continue;
+                    }
+                    r2 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                case 0x66cf4:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67074;
+                        run_67000(); return;
+                    }
+                    r3 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r2 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                case 0x66d0c:
+                    f30 = readPages[(r29+212)>>>12][((r29+212)>>>2)&0x3ff];
+                    f28 = readPages[(r29+204)>>>12][((r29+204)>>>2)&0x3ff];
+                    f26 = readPages[(r29+196)>>>12][((r29+196)>>>2)&0x3ff];
+                    f24 = readPages[(r29+188)>>>12][((r29+188)>>>2)&0x3ff];
+                    f22 = readPages[(r29+180)>>>12][((r29+180)>>>2)&0x3ff];
+                    f20 = readPages[(r29+172)>>>12][((r29+172)>>>2)&0x3ff];
+                    r31 = readPages[(r29+164)>>>12][((r29+164)>>>2)&0x3ff];
+                    f0 = r3;
+                    r30 = readPages[(r29+160)>>>12][((r29+160)>>>2)&0x3ff];
+                    r23 = readPages[(r29+156)>>>12][((r29+156)>>>2)&0x3ff];
+                    r22 = readPages[(r29+152)>>>12][((r29+152)>>>2)&0x3ff];
+                    r21 = readPages[(r29+148)>>>12][((r29+148)>>>2)&0x3ff];
+                    r20 = readPages[(r29+144)>>>12][((r29+144)>>>2)&0x3ff];
+                    r19 = readPages[(r29+140)>>>12][((r29+140)>>>2)&0x3ff];
+                    r18 = readPages[(r29+136)>>>12][((r29+136)>>>2)&0x3ff];
+                    r17 = readPages[(r29+132)>>>12][((r29+132)>>>2)&0x3ff];
+                    r16 = readPages[(r29+128)>>>12][((r29+128)>>>2)&0x3ff];
+                    f31 = readPages[(r29+208)>>>12][((r29+208)>>>2)&0x3ff];
+                    f29 = readPages[(r29+200)>>>12][((r29+200)>>>2)&0x3ff];
+                    f27 = readPages[(r29+192)>>>12][((r29+192)>>>2)&0x3ff];
+                    f25 = readPages[(r29+184)>>>12][((r29+184)>>>2)&0x3ff];
+                    f23 = readPages[(r29+176)>>>12][((r29+176)>>>2)&0x3ff];
+                    f21 = readPages[(r29+168)>>>12][((r29+168)>>>2)&0x3ff];
+                    f1 = r2;
+                    r29 = r29 + 216;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x66d78:
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r0;
+                case 0x66d7c:
+                    r2 = r16 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66cc8;
+                        continue;
+                    }
+                    r16 = r2 + r0;
+                    r2 = r0 + 48;
+                    if(r21 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67010;
+                        run_67000(); return;
+                    }
+                case 0x66da4:
+                    r19 = r0 + r0;
+                case 0x66da8:
+                    r2 = r21 + -48;
+                    r2 = r2 & 255;
+                    r2 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68294;
+                        run_68200(); return;
+                    }
+                    r2 = r16 + 1;
+                    r30 = r0 + r0;
+                    r23 = r0 + r0;
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x66e10;
+                    run_66e00(); return;
+                case 0x66dd4:
+                    r3 = r23 << 1;
+                    r23 = r23 << 3;
+                    r23 = r3 + r23;
+                    r21 = r23 + r21;
+                    r23 = r21 + -48;
+                case 0x66de8:
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    r17 = r2 + r0;
+                    r3 = r21 + -48;
+                    r3 = r3 & 255;
+                    r3 = (r3&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                case 0x66e00:
+                    pc=0x66e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_66e00() throws ExecutionException { /* 0x66e00 - 0x67000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x66e00:
+                    r20 = r20 + 1;
+                    r2 = r2 + 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66e64;
+                        continue;
+                    }
+                case 0x66e10:
+                    r3 = r20 < 16 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66de8;
+                        run_66c00(); return;
+                    }
+                    r3 = r20 < 9 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66dd4;
+                        run_66c00(); return;
+                    }
+                    r3 = r30 << 1;
+                    r30 = r30 << 3;
+                    r30 = r3 + r30;
+                    r21 = r30 + r21;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    r30 = r21 + -48;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    r17 = r2 + r0;
+                    r3 = r21 + -48;
+                    r3 = r3 & 255;
+                    r3 = (r3&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    r20 = r20 + 1;
+                    r2 = r2 + 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66e10;
+                        continue;
+                    }
+                case 0x66e64:
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x66e70;
+                    pc=0x5ae00;
+                    run_5ae00(); return;
+                case 0x66e70:
+                    r5 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    r31=0x66e84;
+                    pc=0x5ae00;
+                    run_5ae00(); return;
+                case 0x66e84:
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x66e90;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x66e90:
+                    r5 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x66ea4;
+                    pc=0x43000;
+                    run_43000(); return;
+                case 0x66ea4:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x672e4;
+                        run_67200(); return;
+                    }
+                    r7 = r20 + r0;
+                    r5 = r0 + r0;
+                    r3 = r0 + r0;
+                    r9 = r0 + r0;
+                case 0x66ebc:
+                    r4 = r0 + -33;
+                    r4 = r21 & r4;
+                    r2 = r0 + 69;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67158;
+                        run_67000(); return;
+                    }
+                case 0x66ed0:
+                    r4 = r0 + r0;
+                case 0x66ed4:
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x670bc;
+                        run_67000(); return;
+                    }
+                case 0x66edc:
+                    r3 = r4 - r3;
+                    writePages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff] = r3;
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66ef0;
+                        continue;
+                    }
+                    r20 = r7 + r0;
+                case 0x66ef0:
+                    r3 = r7 < 17 ? 1 : 0;
+                    r2 = r7 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66f04;
+                        continue;
+                    }
+                    r2 = r0 + 16;
+                case 0x66f04:
+                    f2 = r23;
+                    { long l = Double.doubleToLongBits(((double)f2)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    if(r23 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67ed8;
+                        run_67e00(); return;
+                    }
+                case 0x66f18:
+                    r3 = r2 < 10 ? 1 : 0;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f0;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66f6c;
+                        continue;
+                    }
+                    r4 = r2 + -9;
+                    r3 = 7 << 16;
+                    r4 = r4 << 3;
+                    r3 = r3 + 2176;
+                    r3 = r4 + r3;
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f4 = r30;
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits(((double)f4)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    if(r30 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x682ac;
+                        run_68200(); return;
+                    }
+                case 0x66f60:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f4;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f5;
+                case 0x66f6c:
+                    r3 = r7 < 16 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67354;
+                        run_67200(); return;
+                    }
+                    r3 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x672c4;
+                        run_67200(); return;
+                    }
+                    r3 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    if(r3 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6845c;
+                        run_68400(); return;
+                    }
+                    r3 = r3 < 23 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x682c8;
+                        run_68200(); return;
+                    }
+                    r4 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r2 = 7 << 16;
+                    r3 = r4 << 3;
+                    r2 = r2 + 2176;
+                    r2 = r3 + r2;
+                    f0 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f1 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    f3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f3;
+                    /* Next insn is delay slot */ 
+                    pc=0x66cd8;
+                    run_66c00(); return;
+                case 0x66fe0:
+                    r16 = r16 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    r2 = r21 & 255;
+                    r3 = (r2&0xffffffffL) < (46&0xffffffffL) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66c94;
+                        run_66c00(); return;
+                    }
+                case 0x67000:
+                    pc=0x67000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_67000() throws ExecutionException { /* 0x67000 - 0x67200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x67000:
+                    r2 = r0 + 48;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r0;
+                    if(r21 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66da4;
+                        run_66c00(); return;
+                    }
+                case 0x67010:
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r3 = r0 + 88;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67e68;
+                        run_67e00(); return;
+                    }
+                    r3 = r0 + 120;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67e68;
+                        run_67e00(); return;
+                    }
+                    r2 = r16 + 1;
+                    r3 = r0 + 48;
+                case 0x67034:
+                    r16 = r2 + r0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    r2 = r2 + 1;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    if(r21 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67034;
+                        continue;
+                    }
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6728c;
+                        run_67200(); return;
+                    }
+                    r19 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x66da8;
+                    run_66c00(); return;
+                case 0x67064:
+                    r3 = r0 + 1;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x66d7c;
+                    run_66c00(); return;
+                case 0x67074:
+                    r5 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r4 = 32768 << 16;
+                    r2 = r5 ^ r4;
+                    r3 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x66d0c;
+                    run_66c00(); return;
+                case 0x6708c:
+                    r3 = r0 + r0;
+                case 0x67090:
+                    r2 = r21 + -49;
+                    r2 = (r2&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67e08;
+                        run_67e00(); return;
+                    }
+                    r4 = r0 + -33;
+                    r4 = r21 & r4;
+                    r2 = r0 + 69;
+                    r5 = r3 + r0;
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66cac;
+                        run_66c00(); return;
+                    }
+                    r9 = r0 + 1;
+                case 0x670bc:
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6728c;
+                        run_67200(); return;
+                    }
+                    if(r19 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6728c;
+                        run_67200(); return;
+                    }
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66cc8;
+                        run_66c00(); return;
+                    }
+                    r2 = r0 + 78;
+                    if(r21 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67104;
+                        continue;
+                    }
+                    r2 = r21 < 79 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68518;
+                        run_68400(); return;
+                    }
+                    r2 = r0 + 105;
+                    if(r21 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68524;
+                        run_68400(); return;
+                    }
+                    r2 = r0 + 110;
+                    if(r21 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66cc8;
+                        run_66c00(); return;
+                    }
+                case 0x67104:
+                    r3 = 7 << 16;
+                    r4 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r3 = r3 + 4320;
+                case 0x67110:
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6868c;
+                        run_68600(); return;
+                    }
+                    r4 = r4 + 1;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r6 = r2 + -65;
+                    r6 = r6 & 255;
+                    r6 = (r6&0xffffffffL) < (26&0xffffffffL) ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67148;
+                        continue;
+                    }
+                    r2 = r2 + 32;
+                case 0x67148:
+                    if(r2 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67110;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x66cc8;
+                    run_66c00(); return;
+                case 0x67158:
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66cb8;
+                        run_66c00(); return;
+                    }
+                case 0x67160:
+                    r22 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r2 = r22 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    addr=r22+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    r2 = r0 + 43;
+                    if(r21 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67ca8;
+                        run_67c00(); return;
+                    }
+                    r2 = r0 + 45;
+                    if(r21 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67c9c;
+                        run_67c00(); return;
+                    }
+                    r10 = r0 + 1;
+                case 0x67190:
+                    r2 = r22 + 2;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    addr=r22+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                case 0x671a0:
+                    r2 = r21 + -48;
+                    r2 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67bc8;
+                        run_67a00(); return;
+                    }
+                    r2 = r0 + 48;
+                    if(r21 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x671dc;
+                        continue;
+                    }
+                    r2 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r4 = r0 + 48;
+                    r2 = r2 + 1;
+                case 0x671c8:
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    r2 = r2 + 1;
+                    if(r21 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x671c8;
+                        continue;
+                    }
+                case 0x671dc:
+                    r2 = r21 + -49;
+                    r2 = (r2&0xffffffffL) < (9&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66ed0;
+                        run_66e00(); return;
+                    }
+                    r11 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r4 = r21 + -48;
+                    r8 = r11 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r8;
+                    addr=r11+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                case 0x67200:
+                    pc=0x67200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_67200() throws ExecutionException { /* 0x67200 - 0x67400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x67200:
+                    r2 = r21 + -48;
+                    r2 = r2 & 255;
+                    r2 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67254;
+                        continue;
+                    }
+                    r2 = r11 + 2;
+                case 0x6721c:
+                    r6 = r4 << 1;
+                    r4 = r4 << 3;
+                    r4 = r6 + r4;
+                    r21 = r4 + r21;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    r4 = r21 + -48;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    r8 = r2 + r0;
+                    r6 = r21 + -48;
+                    r6 = r6 & 255;
+                    r6 = (r6&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    r2 = r2 + 1;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6721c;
+                        continue;
+                    }
+                case 0x67254:
+                    r2 = r8 - r11;
+                    r2 = r2 < 9 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67e5c;
+                        run_67e00(); return;
+                    }
+                    r2 = r4 < 20000 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67e5c;
+                        run_67e00(); return;
+                    }
+                case 0x67270:
+                    if(r10 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66ed4;
+                        run_66e00(); return;
+                    }
+                    r4 = r0 - r4;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66edc;
+                        run_66e00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x670bc;
+                    run_67000(); return;
+                case 0x6728c:
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x66cd8;
+                    run_66c00(); return;
+                case 0x6729c:
+                    r4 = 32752 << 16;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r4;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                case 0x672a8:
+                    r2 = r2 & 8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x672c4;
+                        continue;
+                    }
+                    r3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r2 = 32768 << 16;
+                    r2 = r2 | r3;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                case 0x672c4:
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x66cd8;
+                    run_66c00(); return;
+                case 0x672e4:
+                    r4 = r18 + r0;
+                    r17 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x672f4;
+                    pc=0x5ae00;
+                    run_5ae00(); return;
+                case 0x672f4:
+                    r4 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x67300;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x67300:
+                    r2 = r17 + r2;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67be0;
+                        run_67a00(); return;
+                    }
+                    r3 = r0 + 48;
+                    if(r21 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6708c;
+                        run_67000(); return;
+                    }
+                    r3 = r0 + r0;
+                    r5 = r0 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=0x67334;
+                    continue;
+                case 0x67330:
+                    r2 = r4 + r0;
+                case 0x67334:
+                    r4 = r2 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r4;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    r3 = r3 + 1;
+                    if(r21 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67330;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x67090;
+                    run_67000(); return;
+                case 0x67354:
+                    r3 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r2 = r7 - r2;
+                    r2 = r3 + r2;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68110;
+                        run_68000(); return;
+                    }
+                    r3 = r2 & 15;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x673a4;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r3 = r3 << 3;
+                    r4 = r4 + 2176;
+                    r3 = r3 + r4;
+                    f2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f0 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    f1 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f2;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f3;
+                case 0x673a4:
+                    r3 = r0 + -16;
+                    r2 = r2 & r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67cfc;
+                        run_67c00(); return;
+                    }
+                case 0x673b4:
+                    f4 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r22 = r0 + r0;
+                    f5 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f4;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f5;
+                case 0x673cc:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r23;
+                    r5 = r16 + r0;
+                    r4 = r18 + r0;
+                    r6 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x673e4;
+                    pc=0x5be00;
+                    run_5be00(); return;
+                case 0x673e4:
+                    r3 = r2 + 12;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r23 = r2 + r0;
+                    f24 = readPages[(r28+-30924)>>>12][((r28+-30924)>>>2)&0x3ff];
+                    r2 = r0 - r3;
+                    r3 = r3 >> 31;
+                case 0x67400:
+                    pc=0x67400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_67400() throws ExecutionException { /* 0x67400 - 0x67600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x67400:
+                    r16 = r3 & r2;
+                    f20 = readPages[(r28+-30908)>>>12][((r28+-30908)>>>2)&0x3ff];
+                    r3 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    f22 = readPages[(r28+-30932)>>>12][((r28+-30932)>>>2)&0x3ff];
+                    f25 = readPages[(r28+-30928)>>>12][((r28+-30928)>>>2)&0x3ff];
+                    r3 = r0 < r3 ? 1 : 0;
+                    f21 = readPages[(r28+-30912)>>>12][((r28+-30912)>>>2)&0x3ff];
+                    f23 = readPages[(r28+-30936)>>>12][((r28+-30936)>>>2)&0x3ff];
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r3;
+                    f26 = f24;
+                    f27 = f25;
+                case 0x67428:
+                    r5 = readPages[(r23+4)>>>12][((r23+4)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67438;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x67438:
+                    r6 = readPages[(r23+16)>>>12][((r23+16)>>>2)&0x3ff];
+                    r5 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r6 = r6 + 2;
+                    r4 = r2 + 12;
+                    r6 = r6 << 2;
+                    r21 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67458;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x67458:
+                    r5 = r29 + 24;
+                    r7 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r4 = r29 + 32;
+                    r6 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r5;
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6747c;
+                    pc=0x5d600;
+                    run_5d600(); return;
+                case 0x6747c:
+                    r4 = r18 + r0;
+                    r5 = r0 + 1;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x67490;
+                    pc=0x5c400;
+                    run_5c400(); return;
+                case 0x67490:
+                    r3 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r19 = r2 + r0;
+                    r7 = r0 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x674a8;
+                        continue;
+                    }
+                    r7 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                case 0x674a8:
+                    r2 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67920;
+                        run_67800(); return;
+                    }
+                    r20 = r16 + r2;
+                    r3 = r7 + r0;
+                case 0x674c0:
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r2 = r2 - r22;
+                    r5 = r2 + r4;
+                    r5 = r5 < -1021 ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6781c;
+                        run_67800(); return;
+                    }
+                    r2 = r2 + 1075;
+                case 0x674dc:
+                    r30 = r20 + r2;
+                    r4 = r20 < r30 ? 1 : 0;
+                    r2 = r3 + r2;
+                    r17 = r2 + r22;
+                    r2 = r30 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x674fc;
+                        continue;
+                    }
+                    r2 = r20 + r0;
+                case 0x674fc:
+                    r4 = r17 < r2 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6750c;
+                        continue;
+                    }
+                    r2 = r17 + r0;
+                case 0x6750c:
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67520;
+                        continue;
+                    }
+                    r30 = r30 - r2;
+                    r17 = r17 - r2;
+                    r20 = r20 - r2;
+                case 0x67520:
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67578;
+                        continue;
+                    }
+                    r5 = r19 + r0;
+                    r4 = r18 + r0;
+                    r6 = r16 + r0;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x67540;
+                    pc=0x5ca00;
+                    run_5ca00(); return;
+                case 0x67540:
+                    r6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    r5 = r2 + r0;
+                    r19 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67558;
+                    pc=0x5c600;
+                    run_5c600(); return;
+                case 0x67558:
+                    r5 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x6756c;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x6756c:
+                    r2 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    r7 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                case 0x67578:
+                    if(r30 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x675a0;
+                        continue;
+                    }
+                    r5 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x67598;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x67598:
+                    r7 = readPages[(r29+124)>>>12][((r29+124)>>>2)&0x3ff];
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r2;
+                case 0x675a0:
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x675c0;
+                        continue;
+                    }
+                    r5 = r21 + r0;
+                    r4 = r18 + r0;
+                    r6 = r7 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x675bc;
+                    pc=0x5ca00;
+                    run_5ca00(); return;
+                case 0x675bc:
+                    r21 = r2 + r0;
+                case 0x675c0:
+                    if(r17 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x675e0;
+                        continue;
+                    }
+                    r5 = r21 + r0;
+                    r4 = r18 + r0;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x675dc;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x675dc:
+                    r21 = r2 + r0;
+                case 0x675e0:
+                    if(r20 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67600;
+                        run_67600(); return;
+                    }
+                    r5 = r19 + r0;
+                    r4 = r18 + r0;
+                    r6 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x675fc;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x675fc:
+                    r19 = r2 + r0;
+                case 0x67600:
+                    pc=0x67600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_67600() throws ExecutionException { /* 0x67600 - 0x67800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x67600:
+                    r5 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    r6 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67614;
+                    pc=0x5d000;
+                    run_5d000(); return;
+                case 0x67614:
+                    r30 = readPages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff];
+                    r4 = r2 + r0;
+                    writePages[(r2+12)>>>12][((r2+12)>>>2)&0x3ff] = r0;
+                    r5 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67630;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x67630:
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67ef4;
+                        run_67e00(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67fe8;
+                        run_67e00(); return;
+                    }
+                    r4 = r20 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67650;
+                    pc=0x5d800;
+                    run_5d800(); return;
+                case 0x67650:
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<=(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6782c;
+                        run_67800(); return;
+                    }
+                    if(r30 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67930;
+                        run_67800(); return;
+                    }
+                    r3 = readPages[(r28+-30924)>>>12][((r28+-30924)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30928)>>>12][((r28+-30928)>>>2)&0x3ff];
+                    r6 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f26;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f27;
+                case 0x6767c:
+                    r5 = 32752 << 16;
+                    r17 = r6 & r5;
+                    r7 = 32736 << 16;
+                    if(r17 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67878;
+                        run_67800(); return;
+                    }
+                case 0x67690:
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67778;
+                        continue;
+                    }
+                    r5 = 1696 << 16;
+                    r5 = r5 + 1;
+                    r5 = ((r17 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67778;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-30892)>>>12][((r28+-30892)>>>2)&0x3ff];
+                    f2 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-30896)>>>12][((r28+-30896)>>>2)&0x3ff];
+                    f3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<=(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6776c;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-30884)>>>12][((r28+-30884)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-30888)>>>12][((r28+-30888)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<=(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67b58;
+                        run_67a00(); return;
+                    }
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    r2 = f0;
+                case 0x67720:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67b38;
+                        run_67a00(); return;
+                    }
+                    f4 = r2;
+                    { long l = Double.doubleToLongBits(((double)f4)); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    if(r2 < 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67e38;
+                        run_67e00(); return;
+                    }
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f2;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f3;
+                case 0x67744:
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67ba8;
+                        run_67a00(); return;
+                    }
+                    r3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r2 = 32768 << 16;
+                    r4 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r2 = r3 ^ r2;
+                    writePages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff] = r2;
+                    writePages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff] = r4;
+                case 0x67764:
+                    r3 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    r2 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                case 0x6776c:
+                    r5 = 1712 << 16;
+                    r5 = r2 + r5;
+                    r2 = r5 - r17;
+                case 0x67778:
+                    f12 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    f28 = r3;
+                    f13 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    f29 = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x67790;
+                    pc=0x5d200;
+                    run_5d200(); return;
+                case 0x67790:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f29&0xffffffffL) << 32) | (f28&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    f2 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    f3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f3;
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f3;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f2;
+                case 0x677bc:
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x677d4;
+                        continue;
+                    }
+                    r3 = 32752 << 16;
+                    r3 = r2 & r3;
+                    if(r17 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x679f4;
+                        run_67800(); return;
+                    }
+                case 0x677d4:
+                    r5 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x677e4;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x677e4:
+                    r4 = r18 + r0;
+                    r5 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x677f4;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x677f4:
+                    r4 = r18 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67804;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x67800:
+                    pc=0x67800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_67800() throws ExecutionException { /* 0x67800 - 0x67a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x67800:
+                case 0x67804:
+                    r4 = r18 + r0;
+                    r5 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67814;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x67814:
+                    /* Next insn is delay slot */ 
+                    pc=0x67428;
+                    run_67400(); return;
+                case 0x6781c:
+                    r2 = r0 + 54;
+                    r2 = r2 - r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x674dc;
+                    run_67400(); return;
+                case 0x6782c:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f23&0xffffffffL) << 32) | (f22&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f2;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f3;
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x679b8;
+                        continue;
+                    }
+                    r3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r2 = 32768 << 16;
+                    r4 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r2 = r3 ^ r2;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r2;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r4;
+                case 0x67858:
+                    r6 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r5 = 32752 << 16;
+                    r17 = r6 & r5;
+                    r7 = 32736 << 16;
+                    r3 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r2 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    if(r17 != r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67690;
+                        run_67600(); return;
+                    }
+                case 0x67878:
+                    r7 = 64688 << 16;
+                    r7 = r6 + r7;
+                    f28 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f2 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r7;
+                    f30 = r3;
+                    f29 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    f3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    f31 = r2;
+                    f12 = f28;
+                    f13 = f29;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r5;
+                    writePages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff] = f2;
+                    writePages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff] = f3;
+                    /* Next insn is delay slot */ 
+                    r31=0x678b4;
+                    pc=0x5d200;
+                    run_5d200(); return;
+                case 0x678b4:
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f31&0xffffffffL) << 32) | (f30&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r5 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f29&0xffffffffL) << 32) | (f28&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f5;
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f4;
+                    r3 = r5 & r2;
+                    r2 = 31904 << 16;
+                    r2 = ((r3 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67b0c;
+                        run_67a00(); return;
+                    }
+                    r3 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r5 = r5 + -1;
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x680b4;
+                        run_68000(); return;
+                    }
+                case 0x678f0:
+                    r5 = r0 + -1;
+                    r2 = 32751 << 16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r5;
+                    r2 = r2 | 65535;
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x677d4;
+                    run_67600(); return;
+                case 0x67920:
+                    r3 = r7 - r2;
+                    r20 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x674c0;
+                    run_67400(); return;
+                case 0x67930:
+                    r2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67ae4;
+                        run_67a00(); return;
+                    }
+                    r6 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r2 = 15 << 16;
+                    r2 = r2 | 65535;
+                    r2 = r2 & r6;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x679d8;
+                        continue;
+                    }
+                    f2 = readPages[(r28+-30924)>>>12][((r28+-30924)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-30928)>>>12][((r28+-30928)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6826c;
+                        run_68200(); return;
+                    }
+                    f4 = readPages[(r28+-30932)>>>12][((r28+-30932)>>>2)&0x3ff];
+                    r2 = 32768 << 16;
+                    f5 = readPages[(r28+-30936)>>>12][((r28+-30936)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f5;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f4;
+                    r3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r4 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r2 = r3 ^ r2;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = r2;
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = r4;
+                case 0x679a8:
+                    r3 = readPages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff];
+                    r2 = readPages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x6767c;
+                    run_67600(); return;
+                case 0x679b8:
+                    f0 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    f1 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = f0;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x67858;
+                    continue;
+                case 0x679d8:
+                    r6 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                case 0x679dc:
+                    r3 = readPages[(r28+-30900)>>>12][((r28+-30900)>>>2)&0x3ff];
+                    r2 = readPages[(r28+-30904)>>>12][((r28+-30904)>>>2)&0x3ff];
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f24;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f25;
+                    /* Next insn is delay slot */ 
+                    pc=0x6767c;
+                    run_67600(); return;
+                case 0x679f4:
+                    f2 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    f3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                case 0x67a00:
+                    pc=0x67a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_67a00() throws ExecutionException { /* 0x67a00 - 0x67c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x67a00:
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f0 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f0 = (int)(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL))); break; // Round towards zero
+                        case 2: f0 = (int)Math.ceil((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f0 = (int)Math.floor((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    { long l = Double.doubleToLongBits(((double)f0)); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67a4c;
+                        continue;
+                    }
+                    r3 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67cb4;
+                        run_67c00(); return;
+                    }
+                case 0x67a4c:
+                    f0 = readPages[(r28+-30876)>>>12][((r28+-30876)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-30880)>>>12][((r28+-30880)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67a8c;
+                        continue;
+                    }
+                    f0 = readPages[(r28+-30868)>>>12][((r28+-30868)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-30872)>>>12][((r28+-30872)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))<(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x677d4;
+                        run_67600(); return;
+                    }
+                case 0x67a8c:
+                    r5 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67a9c;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x67a9c:
+                    r4 = r18 + r0;
+                    r5 = r21 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67aac;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x67aac:
+                    r4 = r18 + r0;
+                    r5 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67abc;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x67abc:
+                    r4 = r18 + r0;
+                    r5 = r23 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67acc;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x67acc:
+                    r4 = r18 + r0;
+                    r5 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67adc;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x67adc:
+                    /* Next insn is delay slot */ 
+                    pc=0x66cd8;
+                    run_66c00(); return;
+                case 0x67ae4:
+                    r3 = r0 + 1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x679d8;
+                        run_67800(); return;
+                    }
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67fd0;
+                        run_67e00(); return;
+                    }
+                    r6 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x679dc;
+                    run_67800(); return;
+                case 0x67b0c:
+                    r3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r2 = 848 << 16;
+                    r2 = r2 + r3;
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x677bc;
+                    run_67600(); return;
+                case 0x67b38:
+                    f0 = readPages[(r28+-30924)>>>12][((r28+-30924)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-30928)>>>12][((r28+-30928)>>>2)&0x3ff];
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f0;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x67744;
+                    run_67600(); return;
+                case 0x67b58:
+                    f2 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r3 = 32768 << 16;
+                    f3 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    r4 = fcsr;
+                    r4 = fcsr;
+                    r1 = r4 | 3;
+                    r1 = r1 ^ 2;
+                    fcsr = r1;
+                    switch(fcsr & 3) {
+                        case 0: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+0.5); break; // Round to nearest
+                        case 1: f2 = (int)(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL))); break; // Round towards zero
+                        case 2: f2 = (int)Math.ceil((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards plus infinity
+                        case 3: f2 = (int)Math.floor((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); break; // Round towards minus infinity
+                    }
+                    fcsr = r4;
+                    r2 = f2;
+                    r2 = r2 | r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x67720;
+                    run_67600(); return;
+                case 0x67ba8:
+                    f0 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    f1 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    writePages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff] = f0;
+                    writePages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x67764;
+                    run_67600(); return;
+                case 0x67bc8:
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r22;
+                    r4 = r0 + r0;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66edc;
+                        run_66e00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x670bc;
+                    run_67000(); return;
+                case 0x67be0:
+                    r7 = r20 + r0;
+                    r5 = r0 + r0;
+                    r3 = r0 + r0;
+                case 0x67bec:
+                    r2 = r21 + -48;
+                    r4 = (r2&0xffffffffL) < (10&0xffffffffL) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67cf0;
+                        run_67c00(); return;
+                    }
+                    r5 = r5 + 1;
+                case 0x67c00:
+                    pc=0x67c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_67c00() throws ExecutionException { /* 0x67c00 - 0x67e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x67c00:
+                    r9 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67e24;
+                        run_67e00(); return;
+                    }
+                    r2 = r0 + 1;
+                    r4 = r5 + r0;
+                    r6 = r7 < 17 ? 1 : 0;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67c60;
+                        continue;
+                    }
+                    r2 = r7 + 1;
+                    r8 = r5 + r7;
+                    r6 = r7 < 17 ? 1 : 0;
+                case 0x67c30:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67c50;
+                        continue;
+                    }
+                    r4 = r2 < 10 ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67ec4;
+                        run_67e00(); return;
+                    }
+                    r4 = r23 << 1;
+                    r23 = r23 << 3;
+                    r23 = r4 + r23;
+                case 0x67c50:
+                    r2 = r2 + 1;
+                    r4 = r5 + r0;
+                    if(r2 != r8) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67c30;
+                        continue;
+                    }
+                case 0x67c60:
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6850c;
+                        run_68400(); return;
+                    }
+                case 0x67c68:
+                    r2 = r7 + r5;
+                    r2 = r2 < 10 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68674;
+                        run_68600(); return;
+                    }
+                    r2 = r23 << 1;
+                    r23 = r23 << 3;
+                    r23 = r2 + r23;
+                    r23 = r23 + r21;
+                case 0x67c88:
+                    r3 = r3 + r4;
+                    r7 = r7 + r4;
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x67e24;
+                    run_67e00(); return;
+                case 0x67c9c:
+                    r10 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x671a0;
+                    run_67000(); return;
+                case 0x67ca8:
+                    r10 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x67190;
+                    run_67000(); return;
+                case 0x67cb4:
+                    r3 = 15 << 16;
+                    r3 = r3 | 65535;
+                    r2 = r2 & r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67a4c;
+                        run_67a00(); return;
+                    }
+                    f0 = readPages[(r28+-30860)>>>12][((r28+-30860)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-30864)>>>12][((r28+-30864)>>>2)&0x3ff];
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))<(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x677d4;
+                        run_67600(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x67a8c;
+                    run_67a00(); return;
+                case 0x67cf0:
+                    r9 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x66ebc;
+                    run_66e00(); return;
+                case 0x67cfc:
+                    r3 = r2 < 309 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x680f4;
+                        run_68000(); return;
+                    }
+                    r2 = r2 >> 4;
+                    r3 = r2 < 2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68708;
+                        run_68600(); return;
+                    }
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r6 = 7 << 16;
+                    r6 = r6 + 2136;
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r3 = r6 + r0;
+                    r4 = r0 + r0;
+                case 0x67d30:
+                    r5 = r2 & 1;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67d50;
+                        continue;
+                    }
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x67d50:
+                    r2 = r2 >> 1;
+                    r5 = r2 < 2 ? 1 : 0;
+                    r4 = r4 + 1;
+                    r3 = r3 + 8;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67d30;
+                        continue;
+                    }
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f0;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f1;
+                case 0x67d70:
+                    r3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r4 = r4 << 3;
+                    r6 = r6 + r4;
+                    r2 = 64688 << 16;
+                    r2 = r2 + r3;
+                    f2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f0 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    f3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    f1 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r2 = 32752 << 16;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r4 = 31904 << 16;
+                    r4 = r4 + 1;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f3;
+                    r5 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f2;
+                    r3 = r2 & r5;
+                    r4 = ((r3 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x680f4;
+                        run_68000(); return;
+                    }
+                    r4 = 31888 << 16;
+                    r4 = r4 + 1;
+                    r3 = ((r3 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68578;
+                        run_68400(); return;
+                    }
+                    r2 = r2 + -1;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r2;
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r22 = r0 + r0;
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                case 0x67e00:
+                    pc=0x67e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_67e00() throws ExecutionException { /* 0x67e00 - 0x68000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x67e00:
+                    /* Next insn is delay slot */ 
+                    pc=0x673cc;
+                    run_67200(); return;
+                case 0x67e08:
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r21 = r21 + -48;
+                    r9 = r16 + r0;
+                    r7 = r0 + r0;
+                    if(r21 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68370;
+                        run_68200(); return;
+                    }
+                    r5 = r0 + 1;
+                case 0x67e24:
+                    r2 = r9 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    addr=r9+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r21 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x67bec;
+                    run_67a00(); return;
+                case 0x67e38:
+                    f0 = readPages[(r28+-30916)>>>12][((r28+-30916)>>>2)&0x3ff];
+                    f1 = readPages[(r28+-30920)>>>12][((r28+-30920)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f2;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f3;
+                    /* Next insn is delay slot */ 
+                    pc=0x67744;
+                    run_67600(); return;
+                case 0x67e5c:
+                    r4 = r0 + 19999;
+                    /* Next insn is delay slot */ 
+                    pc=0x67270;
+                    run_67200(); return;
+                case 0x67e68:
+                    r3 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r2 = r29 + 36;
+                    r19 = 7 << 16;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r3;
+                    r4 = r18 + r0;
+                    r5 = r29 + 40;
+                    r6 = r19 + 12276;
+                    r7 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    r31=0x67e94;
+                    pc=0x6b600;
+                    run_6b600(); return;
+                case 0x67e94:
+                    r17 = r2 & 7;
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6728c;
+                        run_67200(); return;
+                    }
+                    r3 = r0 + 6;
+                    if(r17 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68380;
+                        run_68200(); return;
+                    }
+                    r16 = r16 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x66cd8;
+                    run_66c00(); return;
+                case 0x67ec4:
+                    r4 = r30 << 1;
+                    r30 = r30 << 3;
+                    r30 = r4 + r30;
+                    /* Next insn is delay slot */ 
+                    pc=0x67c50;
+                    run_67c00(); return;
+                case 0x67ed8:
+                    f2 = readPages[(r28+-30916)>>>12][((r28+-30916)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-30920)>>>12][((r28+-30920)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))+(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x66f18;
+                    run_66e00(); return;
+                case 0x67ef4:
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6804c;
+                        run_68000(); return;
+                    }
+                    r4 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6804c;
+                        run_68000(); return;
+                    }
+                    r16 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r2 = 15 << 16;
+                    r2 = r2 | 65535;
+                    r2 = r2 & r16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6804c;
+                        run_68000(); return;
+                    }
+                    r3 = 32752 << 16;
+                    r2 = 1712 << 16;
+                    r3 = r3 & r16;
+                    r2 = r2 + 1;
+                    r2 = ((r3 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6804c;
+                        run_68000(); return;
+                    }
+                    r2 = readPages[(r20+20)>>>12][((r20+20)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67f64;
+                        continue;
+                    }
+                    r2 = readPages[(r20+16)>>>12][((r20+16)>>>2)&0x3ff];
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6804c;
+                        run_68000(); return;
+                    }
+                case 0x67f64:
+                    r5 = r20 + r0;
+                    r4 = r18 + r0;
+                    r6 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x67f78;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x67f78:
+                    r4 = r2 + r0;
+                    r5 = r19 + r0;
+                    r20 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x67f8c;
+                    pc=0x5ce00;
+                    run_5ce00(); return;
+                case 0x67f8c:
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6804c;
+                        run_68000(); return;
+                    }
+                    r2 = r16 + r0;
+                case 0x67f98:
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x686b8;
+                        run_68600(); return;
+                    }
+                    r3 = 32752 << 16;
+                    r4 = 1712 << 16;
+                    r3 = r2 & r3;
+                    r4 = r4 + 1;
+                    r4 = ((r3 & 0xffffffffL) < (r4 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x686b8;
+                        run_68600(); return;
+                    }
+                    r2 = 880 << 16;
+                    r2 = r2 + 1;
+                    r3 = ((r3 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68054;
+                        run_68000(); return;
+                    }
+                case 0x67fd0:
+                    r2 = r0 + 34;
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r2;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x67a8c;
+                    run_67a00(); return;
+                case 0x67fe8:
+                    if(r30 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6833c;
+                        run_68200(); return;
+                    }
+                    r4 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r2 = 15 << 16;
+                    r2 = r2 | 65535;
+                    r3 = r2 & r4;
+                case 0x68000:
+                    pc=0x68000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_68000() throws ExecutionException { /* 0x68000 - 0x68200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x68000:
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x685a0;
+                        run_68400(); return;
+                    }
+                    r2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                case 0x68010:
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6804c;
+                        continue;
+                    }
+                    f12 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    f13 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x68030;
+                    pc=0x5d200;
+                    run_5d200(); return;
+                case 0x68030:
+                    f2 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    f3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f3;
+                case 0x6804c:
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67a8c;
+                        run_67a00(); return;
+                    }
+                case 0x68054:
+                    writePages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff] = r0;
+                    f0 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r4 = 14672 << 16;
+                    f2 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    writePages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff] = r4;
+                    f1 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    f3 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f1;
+                    r2 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67a8c;
+                        run_67a00(); return;
+                    }
+                    r3 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67a8c;
+                        run_67a00(); return;
+                    }
+                    r2 = r0 + 34;
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x67a8c;
+                    run_67a00(); return;
+                case 0x680b4:
+                    r4 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    r2 = r0 + -1;
+                    if(r4 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x678f0;
+                        run_67800(); return;
+                    }
+                    r2 = r0 + 34;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r2;
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r2 = 32752 << 16;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x67a8c;
+                    run_67a00(); return;
+                case 0x680f4:
+                    r2 = r0 + 34;
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r2;
+                case 0x680fc:
+                    r2 = 32752 << 16;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x672c4;
+                    run_67200(); return;
+                case 0x68110:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x673b4;
+                        run_67200(); return;
+                    }
+                    r2 = r0 - r2;
+                    r3 = r2 & 15;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68158;
+                        continue;
+                    }
+                    r4 = 7 << 16;
+                    r3 = r3 << 3;
+                    r4 = r4 + 2176;
+                    r3 = r3 + r4;
+                    f2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f0 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    f1 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f2;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f3;
+                case 0x68158:
+                    r2 = r2 >> 4;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x673b4;
+                        run_67200(); return;
+                    }
+                    r3 = r2 < 32 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68254;
+                        run_68200(); return;
+                    }
+                    r3 = r2 & 16;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6871c;
+                        run_68600(); return;
+                    }
+                    r22 = r0 + r0;
+                case 0x68180:
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x681d0;
+                        continue;
+                    }
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r3 = 7 << 16;
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r3 = r3 + 4536;
+                case 0x68198:
+                    r4 = r2 & 1;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x681b8;
+                        continue;
+                    }
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))*(Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))); f1 = (int)(l >>> 32); f0 = (int)l; }
+                case 0x681b8:
+                    r2 = r2 >> 1;
+                    r3 = r3 + 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68198;
+                        continue;
+                    }
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = f0;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = f1;
+                case 0x681d0:
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68218;
+                        run_68200(); return;
+                    }
+                    r3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r4 = r0 + 107;
+                    r2 = r3 << 1;
+                    r2 = r2 >>> 21;
+                    r2 = r4 - r2;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68218;
+                        run_68200(); return;
+                    }
+                    r4 = r2 < 32 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6876c;
+                        run_68600(); return;
+                    }
+                case 0x68200:
+                    pc=0x68200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_68200() throws ExecutionException { /* 0x68200 - 0x68400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x68200:
+                    r4 = r2 < 53 ? 1 : 0;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6878c;
+                        run_68600(); return;
+                    }
+                    r2 = 880 << 16;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                case 0x68218:
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                    f2 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    f0 = r0;
+                    f3 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    f1 = r0;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (0!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x673cc;
+                        run_67200(); return;
+                    }
+                case 0x68254:
+                    r2 = r0 + 34;
+                    writePages[(r18+0)>>>12][((r18+0)>>>2)&0x3ff] = r2;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x66cd8;
+                    run_66c00(); return;
+                case 0x6826c:
+                    f2 = readPages[(r28+-30940)>>>12][((r28+-30940)>>>2)&0x3ff];
+                    f4 = readPages[(r28+-30932)>>>12][((r28+-30932)>>>2)&0x3ff];
+                    f3 = readPages[(r28+-30944)>>>12][((r28+-30944)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-30936)>>>12][((r28+-30936)>>>2)&0x3ff];
+                    writePages[(r29+116)>>>12][((r29+116)>>>2)&0x3ff] = f2;
+                    writePages[(r29+112)>>>12][((r29+112)>>>2)&0x3ff] = f3;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = f4;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = f5;
+                    /* Next insn is delay slot */ 
+                    pc=0x679a8;
+                    run_67800(); return;
+                case 0x68294:
+                    r17 = r16 + r0;
+                    r30 = r0 + r0;
+                    r23 = r0 + r0;
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x66e64;
+                    run_66e00(); return;
+                case 0x682ac:
+                    f4 = readPages[(r28+-30916)>>>12][((r28+-30916)>>>2)&0x3ff];
+                    f5 = readPages[(r28+-30920)>>>12][((r28+-30920)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))+(Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    /* Next insn is delay slot */ 
+                    pc=0x66f60;
+                    run_66e00(); return;
+                case 0x682c8:
+                    r3 = r0 + 37;
+                    r4 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r3 = r3 - r7;
+                    r3 = r3 < r4 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67354;
+                        run_67200(); return;
+                    }
+                    r2 = r0 + 15;
+                    r7 = r2 - r7;
+                    r2 = 7 << 16;
+                    r2 = r2 + 2176;
+                    r3 = r7 << 3;
+                    r3 = r3 + r2;
+                    f2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r3 = r4 - r7;
+                    r3 = r3 << 3;
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    r2 = r3 + r2;
+                    f0 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f1 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))*(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f4;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f5;
+                    /* Next insn is delay slot */ 
+                    pc=0x66cd8;
+                    run_66c00(); return;
+                case 0x6833c:
+                    r2 = 15 << 16;
+                    r3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r2 = r2 | 65535;
+                    r2 = r2 & r3;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x684a8;
+                        run_68400(); return;
+                    }
+                    r4 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x684a8;
+                        run_68400(); return;
+                    }
+                    r2 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x67f98;
+                    run_67e00(); return;
+                case 0x68370:
+                    r4 = r0 + 1;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x67c68;
+                    run_67c00(); return;
+                case 0x68380:
+                    r6 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x683b8;
+                        continue;
+                    }
+                    r5 = readPages[(r19+12276)>>>12][((r19+12276)>>>2)&0x3ff];
+                    r4 = r29 + 24;
+                    writePages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    r31=0x683a4;
+                    pc=0x5dc00;
+                    run_5dc00(); return;
+                case 0x683a4:
+                    r5 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r4 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x683b4;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x683b4:
+                    r2 = readPages[(r29+120)>>>12][((r29+120)>>>2)&0x3ff];
+                case 0x683b8:
+                    r3 = (r17&0xffffffffL) < (7&0xffffffffL) ? 1 : 0;
+                    r4 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x672a8;
+                        run_67200(); return;
+                    }
+                    r3 = 7 << 16;
+                    r17 = r17 << 2;
+                    r3 = r3 + 4508;
+                    r3 = r3 + r17;
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    return;
+                case 0x683e8:
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r4;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x672a8;
+                    run_67200(); return;
+                case 0x68400:
+                    pc=0x68400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_68400() throws ExecutionException { /* 0x68400 - 0x68600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x68400:
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r3;
+                    r3 = 65519 << 16;
+                    r4 = r4 + 1075;
+                    r3 = r3 | 65535;
+                    r4 = r4 << 20;
+                    r3 = r5 & r3;
+                    r3 = r4 | r3;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x672a8;
+                    run_67200(); return;
+                case 0x68430:
+                    r3 = 32767 << 16;
+                    r3 = r3 | 65535;
+                    r5 = r0 + -1;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r3;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r5;
+                    /* Next insn is delay slot */ 
+                    pc=0x672a8;
+                    run_67200(); return;
+                case 0x6844c:
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x672a8;
+                    run_67200(); return;
+                case 0x6845c:
+                    r4 = readPages[(r29+92)>>>12][((r29+92)>>>2)&0x3ff];
+                    r3 = r4 < -22 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67354;
+                        run_67200(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r4 << 3;
+                    r3 = r3 + 2176;
+                    r2 = r3 - r2;
+                    f0 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    f2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    f1 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    f3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f3&0xffffffffL) << 32) | (f2&0xffffffffL)))/(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f3 = (int)(l >>> 32); f2 = (int)l; }
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f3;
+                    /* Next insn is delay slot */ 
+                    pc=0x66cd8;
+                    run_66c00(); return;
+                case 0x684a8:
+                    r2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6804c;
+                        run_68000(); return;
+                    }
+                    f12 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    f13 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x684d0;
+                    pc=0x5d200;
+                    run_5d200(); return;
+                case 0x684d0:
+                    f4 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    f5 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    { long l = Double.doubleToLongBits((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))-(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))); f5 = (int)(l >>> 32); f4 = (int)l; }
+                    f0 = r0;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f4;
+                    f1 = r0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f5;
+                    fcsr = (fcsr&~0x800000) | (((Double.longBitsToDouble(((f5&0xffffffffL) << 32) | (f4&0xffffffffL)))==(Double.longBitsToDouble(((f1&0xffffffffL) << 32) | (f0&0xffffffffL)))) ? 0x800000 : 0x000000);
+                    if(((fcsr&0x800000)!=0) == (1!=0)) {
+                        /* Next insn is delay slot */ 
+                        pc=0x67fd0;
+                        run_67e00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6804c;
+                    run_68000(); return;
+                case 0x6850c:
+                    r5 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x67e24;
+                    run_67e00(); return;
+                case 0x68518:
+                    r2 = r0 + 73;
+                    if(r21 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x66cc8;
+                        run_66c00(); return;
+                    }
+                case 0x68524:
+                    r4 = 7 << 16;
+                    r2 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r4 = r4 + 4308;
+                case 0x68530:
+                    r4 = r4 + 1;
+                    addr=r4+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68618;
+                        run_68600(); return;
+                    }
+                    r2 = r2 + 1;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r6 = r3 + -65;
+                    r6 = r6 & 255;
+                    r6 = (r6&0xffffffffL) < (26&0xffffffffL) ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68568;
+                        continue;
+                    }
+                    r3 = r3 + 32;
+                case 0x68568:
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68530;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x66cc8;
+                    run_66c00(); return;
+                case 0x68578:
+                    r2 = 848 << 16;
+                    r2 = r5 + r2;
+                    f2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    f3 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r22 = r0 + r0;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f2;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f3;
+                    /* Next insn is delay slot */ 
+                    pc=0x673cc;
+                    run_67200(); return;
+                case 0x685a0:
+                    r2 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x686fc;
+                        run_68600(); return;
+                    }
+                    r3 = 32752 << 16;
+                    r5 = 1696 << 16;
+                    r3 = r4 & r3;
+                    r5 = r5 + 1;
+                    r5 = ((r3 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x686fc;
+                        run_68600(); return;
+                    }
+                    r5 = r0 + 107;
+                    r3 = r3 >>> 20;
+                    r3 = r5 - r3;
+                    r5 = r0 + -1;
+                    r3 = r5 << (r3&0x1f);
+                case 0x685dc:
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68010;
+                        run_68000(); return;
+                    }
+                    r2 = 32752 << 16;
+                    r4 = r4 & r2;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                    r2 = 16 << 16;
+                    r2 = r4 + r2;
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                case 0x68600:
+                    pc=0x68600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_68600() throws ExecutionException { /* 0x68600 - 0x68800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x68600:
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6804c;
+                    run_68000(); return;
+                case 0x68618:
+                    r4 = 7 << 16;
+                    r7 = r2 + r0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    r4 = r4 + 4312;
+                case 0x68628:
+                    r4 = r4 + 1;
+                    addr=r4+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r2 = r2 + 1;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68668;
+                        continue;
+                    }
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r6 = r3 + -65;
+                    r6 = r6 & 255;
+                    r6 = (r6&0xffffffffL) < (26&0xffffffffL) ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6865c;
+                        continue;
+                    }
+                    r3 = r3 + 32;
+                case 0x6865c:
+                    if(r3 == r5) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68628;
+                        continue;
+                    }
+                    r2 = r7 + 1;
+                case 0x68668:
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x680fc;
+                    run_68000(); return;
+                case 0x68674:
+                    r2 = r30 << 1;
+                    r30 = r30 << 3;
+                    r30 = r2 + r30;
+                    r30 = r30 + r21;
+                    /* Next insn is delay slot */ 
+                    pc=0x67c88;
+                    run_67c00(); return;
+                case 0x6868c:
+                    r2 = r4 + 1;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r2;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r3 = tmp;
+                    r2 = r0 + 40;
+                    if(r3 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68728;
+                        continue;
+                    }
+                case 0x686a4:
+                    r4 = 32760 << 16;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r4;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x672c4;
+                    run_67200(); return;
+                case 0x686b8:
+                    r3 = 32752 << 16;
+                    r2 = r2 & r3;
+                    r3 = 65520 << 16;
+                    r3 = r2 + r3;
+                    r5 = r0 + -1;
+                    r2 = 15 << 16;
+                    r2 = r2 | 65535;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r5;
+                    r2 = r3 | r2;
+                    f0 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    f1 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = f0;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = f1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6804c;
+                    run_68000(); return;
+                case 0x686fc:
+                    r3 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x685dc;
+                    run_68400(); return;
+                case 0x68708:
+                    r6 = 7 << 16;
+                    r4 = r0 + r0;
+                    r6 = r6 + 2136;
+                    /* Next insn is delay slot */ 
+                    pc=0x67d70;
+                    run_67c00(); return;
+                case 0x6871c:
+                    r22 = r0 + 106;
+                    /* Next insn is delay slot */ 
+                    pc=0x68180;
+                    run_68000(); return;
+                case 0x68728:
+                    r5 = 7 << 16;
+                    r4 = r29 + 40;
+                    r5 = r5 + 12256;
+                    r6 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x68740;
+                    pc=0x6c200;
+                    run_6c200(); return;
+                case 0x68740:
+                    r3 = r0 + 5;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x686a4;
+                        continue;
+                    }
+                    r2 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r3 = 32752 << 16;
+                    r2 = r3 | r2;
+                    r3 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x672c4;
+                    run_67200(); return;
+                case 0x6876c:
+                    r3 = r0 + -1;
+                    r2 = r3 << (r2&0x1f);
+                    r3 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r2 = r2 & r3;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x68218;
+                    run_68200(); return;
+                case 0x6878c:
+                    r4 = r0 + -1;
+                    r2 = r4 << (r2&0x1f);
+                    r2 = r2 & r3;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x68218;
+                    run_68200(); return;
+                case 0x68800:
+                    pc=0x68800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_68800() throws ExecutionException { /* 0x68800 - 0x68a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x68800:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x66c00;
+                    run_66c00(); return;
+                case 0x68a00:
+                    pc=0x68a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_68a00() throws ExecutionException { /* 0x68a00 - 0x68c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x68a00:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r29 = r29 + -32;
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = f21;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = f20;
+                    /* Next insn is delay slot */ 
+                    r31=0x68a28;
+                    pc=0x66c00;
+                    run_66c00(); return;
+                case 0x68a28:
+                    f12 = f0;
+                    f13 = f1;
+                    f20 = f0;
+                    f21 = f1;
+                    /* Next insn is delay slot */ 
+                    r31=0x68a38;
+                    pc=0x37a00;
+                    run_37a00(); return;
+                case 0x68a38:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68a60;
+                        continue;
+                    }
+                    f0=Float.floatToRawIntBits((float)(Double.longBitsToDouble(((f21&0xffffffffL) << 32) | (f20&0xffffffffL))));
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x68a60:
+                    f20 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    f21 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r4 = r0 + r0;
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=0x66a00;
+                    run_66a00(); return;
+                case 0x68c00:
+                    pc=0x68c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_68c00() throws ExecutionException { /* 0x68c00 - 0x68e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x68c00:
+                    r2 = r0 + -1;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68d24;
+                        continue;
+                    }
+                    addr=r6+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r29 = r29 + -32;
+                    r2 = r2 & 65503;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r16;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    addr=r6+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r6+48)>>>12][((r6+48)>>>2)&0x3ff];
+                    r16 = r5 & 255;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68cb0;
+                        continue;
+                    }
+                    r3 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    r2 = readPages[(r6+52)>>>12][((r6+52)>>>2)&0x3ff];
+                    r2 = r3 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68c88;
+                        continue;
+                    }
+                case 0x68c4c:
+                    r2 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    r3 = r2 + -1;
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r3;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r16&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = r2;
+                    r2 = r16 + r0;
+                case 0x68c74:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x68c88:
+                    r5 = r6 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x68c98;
+                    pc=0x6a200;
+                    run_6a200(); return;
+                case 0x68c98:
+                    r6 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68c4c;
+                        continue;
+                    }
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x68c74;
+                    continue;
+                case 0x68cb0:
+                    r2 = readPages[(r6+16)>>>12][((r6+16)>>>2)&0x3ff];
+                    r3 = readPages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68cdc;
+                        continue;
+                    }
+                    r2 = ((r2 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68cdc;
+                        continue;
+                    }
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68d30;
+                        continue;
+                    }
+                case 0x68cdc:
+                    r2 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    addr=r6+66;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r16&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r6+60)>>>12][((r6+60)>>>2)&0x3ff] = r2;
+                    r2 = r6 + 64;
+                    writePages[(r6+48)>>>12][((r6+48)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 3;
+                    writePages[(r6+52)>>>12][((r6+52)>>>2)&0x3ff] = r2;
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r6 + 66;
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = r2;
+                    writePages[(r6+56)>>>12][((r6+56)>>>2)&0x3ff] = r3;
+                    r2 = r16 + r0;
+                    r16 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x68d24:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x68d30:
+                    r3 = r3 + -1;
+                    writePages[(r6+0)>>>12][((r6+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r6+4)>>>12][((r6+4)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x68c74;
+                    continue;
+                case 0x68e00:
+                    pc=0x68e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_68e00() throws ExecutionException { /* 0x68e00 - 0x69000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x68e00:
+                    r29 = r29 + -24;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r5 + r0;
+                    r5 = readPages[(r5+48)>>>12][((r5+48)>>>2)&0x3ff];
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r31;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68e68;
+                        continue;
+                    }
+                    r2 = r16 + 64;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68e30;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    r31=0x68e30;
+                    pc=0x3ca00;
+                    run_3ca00(); return;
+                case 0x68e30:
+                    r2 = readPages[(r16+60)>>>12][((r16+60)>>>2)&0x3ff];
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r0;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x68e68;
+                        continue;
+                    }
+                    r2 = readPages[(r16+56)>>>12][((r16+56)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + r0;
+                case 0x68e54:
+                    r31 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x68e68:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 | 32;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x68e54;
+                    continue;
+                case 0x69000:
+                    pc=0x69000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_69000() throws ExecutionException { /* 0x69000 - 0x69200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x69000:
+                    { long hilo = (long)(r7) * ((long)r6); hi = (int) (hilo >>> 32); lo = (int) hilo; }
+                    r29 = r29 + -56;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r21;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r23;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r22;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r16;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r20;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r19;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r18;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r17;
+                    r22 = r6 + r0;
+                    r21 = lo;
+                    r23 = r7 + r0;
+                    r16 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6910c;
+                        continue;
+                    }
+                    r20 = r4 + r0;
+                    r19 = r5 + r0;
+                    r18 = lo;
+                    /* Next insn is delay slot */ 
+                    pc=0x69094;
+                    continue;
+                case 0x69058:
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x69064;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x69064:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r0;
+                    r2 = r2 + r17;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r4 = r20 + r0;
+                    r5 = r16 + r0;
+                    r19 = r19 + r17;
+                    r18 = r18 - r17;
+                    /* Next insn is delay slot */ 
+                    r31=0x6908c;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x6908c:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69118;
+                        continue;
+                    }
+                case 0x69094:
+                    r17 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r4 = r19 + r0;
+                    r3 = ((r17 & 0xffffffffL) < (r18 & 0xffffffffL)) ? 1 : 0;
+                    r5 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69058;
+                        continue;
+                    }
+                    r6 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x690b8;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x690b8:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r2 - r18;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r18 = r2 + r18;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r18;
+                    r2 = r23 + r0;
+                case 0x690dc:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r23 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r22 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r21 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r20 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r19 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r18 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r17 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6910c:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x690dc;
+                    continue;
+                case 0x69118:
+                    r2 = r21 - r18;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        if(r22!=0) {
+                        hi = (int)((r2 & 0xffffffffL) % (r22 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r22 & 0xffffffffL));
+                        }
+                        pc=0x69128;
+                        continue;
+                    }
+                    if(r22!=0) {
+                    hi = (int)((r2 & 0xffffffffL) % (r22 & 0xffffffffL)); lo = (int)((r2 & 0xffffffffL) / (r22 & 0xffffffffL));
+                    }
+                    throw new ExecutionException("Break");
+                case 0x69128:
+                    r2 = lo;
+                    /* Next insn is delay slot */ 
+                    pc=0x690dc;
+                    continue;
+                case 0x69200:
+                    pc=0x69200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_69200() throws ExecutionException { /* 0x69200 - 0x69400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x69200:
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r29 = r29 + -416;
+                    writePages[(r29+380)>>>12][((r29+380)>>>2)&0x3ff] = r17;
+                    r17 = r4 + r0;
+                    r4 = r2 & 8192;
+                    writePages[(r29+408)>>>12][((r29+408)>>>2)&0x3ff] = r30;
+                    writePages[(r29+376)>>>12][((r29+376)>>>2)&0x3ff] = r16;
+                    writePages[(r29+412)>>>12][((r29+412)>>>2)&0x3ff] = r31;
+                    writePages[(r29+404)>>>12][((r29+404)>>>2)&0x3ff] = r23;
+                    writePages[(r29+400)>>>12][((r29+400)>>>2)&0x3ff] = r22;
+                    writePages[(r29+396)>>>12][((r29+396)>>>2)&0x3ff] = r21;
+                    writePages[(r29+392)>>>12][((r29+392)>>>2)&0x3ff] = r20;
+                    writePages[(r29+388)>>>12][((r29+388)>>>2)&0x3ff] = r19;
+                    writePages[(r29+384)>>>12][((r29+384)>>>2)&0x3ff] = r18;
+                    r30 = r5 + r0;
+                    r16 = r6 + r0;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r7;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69264;
+                        continue;
+                    }
+                    r2 = r2 | 8192;
+                    r4 = readPages[(r5+100)>>>12][((r5+100)>>>2)&0x3ff];
+                    addr=r5+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + -8193;
+                    r2 = r4 & r2;
+                    writePages[(r5+100)>>>12][((r5+100)>>>2)&0x3ff] = r2;
+                case 0x69264:
+                    r19 = 7 << 16;
+                    writePages[(r29+344)>>>12][((r29+344)>>>2)&0x3ff] = r0;
+                    r18 = r0 + r0;
+                    r23 = r0 + r0;
+                    writePages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff] = r0;
+                    r19 = r19 + 4576;
+                case 0x6927c:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r16 = r16 + 1;
+                    writePages[(r29+328)>>>12][((r29+328)>>>2)&0x3ff] = r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69484;
+                        run_69400(); return;
+                    }
+                case 0x69290:
+                    r5 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r4 = r5 + r2;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 8;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6932c;
+                        continue;
+                    }
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69308;
+                        continue;
+                    }
+                case 0x692c0:
+                    r4 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r5 + r2;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 8;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6927c;
+                        continue;
+                    }
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r4 = r4 + 1;
+                    r2 = r2 + -1;
+                    r23 = r23 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r4;
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x692c0;
+                        continue;
+                    }
+                case 0x69308:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x69318;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x69318:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6927c;
+                        continue;
+                    }
+                    r5 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x692c0;
+                    continue;
+                case 0x6932c:
+                    r4 = r0 + 37;
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69500;
+                        run_69400(); return;
+                    }
+                    r21 = r0 + r0;
+                    r22 = r0 + r0;
+                case 0x69340:
+                    r16 = r16 + 1;
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    r2 = r4 & 255;
+                    r6 = (r2&0xffffffffL) < (121&0xffffffffL) ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69374;
+                        continue;
+                    }
+                    r2 = r2 << 2;
+                    r2 = r19 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x69374:
+                    r4 = r5 + r4;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r2 = r0 + 1;
+                    r4 = r4 & 3;
+                    if(r4 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69390;
+                        continue;
+                    }
+                case 0x6938c:
+                    r21 = r21 | 1;
+                case 0x69390:
+                    r3 = 4 << 16;
+                    r3 = r3 + 12800;
+                    writePages[(r29+344)>>>12][((r29+344)>>>2)&0x3ff] = r3;
+                    r18 = r0 + 10;
+                    r20 = r0 + 3;
+                case 0x693a4:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6956c;
+                        run_69400(); return;
+                    }
+                case 0x693b4:
+                    r2 = r21 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x694a8;
+                        run_69400(); return;
+                    }
+                case 0x693c0:
+                    r2 = r0 + 2;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69714;
+                        run_69600(); return;
+                    }
+                    r2 = r0 + 3;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x696a0;
+                        run_69600(); return;
+                    }
+                    r2 = r0 + 1;
+                    if(r20 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x695e0;
+                        run_69400(); return;
+                    }
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x693f0;
+                        continue;
+                    }
+                    r22 = r0 + 1;
+                case 0x693f0:
+                    r2 = r21 & 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69cd8;
+                        run_69c00(); return;
+                    }
+                    r21 = r21 & 16;
+                case 0x69400:
+                    pc=0x69400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_69400() throws ExecutionException { /* 0x69400 - 0x69600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x69400:
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69e78;
+                        run_69e00(); return;
+                    }
+                    r21 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x69440;
+                    continue;
+                case 0x69414:
+                    r4 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r21 = r21 + r2;
+                    r22 = r22 - r2;
+                    r2 = r4 + r2;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x69438;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x69438:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69fa4;
+                        run_69e00(); return;
+                    }
+                case 0x69440:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r4 = r2 < r22 ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69414;
+                        continue;
+                    }
+                    r2 = r2 - r22;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r21 = r21 + r22;
+                    r9 = r2 + r22;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r9;
+                case 0x6946c:
+                    r23 = r23 + r21;
+                case 0x69470:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r2 = tmp;
+                    r16 = r16 + 1;
+                    writePages[(r29+328)>>>12][((r29+328)>>>2)&0x3ff] = r2;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69290;
+                        run_69200(); return;
+                    }
+                case 0x69484:
+                    r2 = readPages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x695ac;
+                    continue;
+                case 0x69490:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x694a0;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x694a0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        continue;
+                    }
+                case 0x694a8:
+                    r5 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x694c0;
+                    continue;
+                case 0x694b8:
+                    r2 = r2 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                case 0x694c0:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r5 + r4;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 8;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x693c0;
+                        run_69200(); return;
+                    }
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r23 = r23 + 1;
+                    r4 = r4 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    if(r4 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x694b8;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x69490;
+                    continue;
+                case 0x69500:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69fb8;
+                        run_69e00(); return;
+                    }
+                case 0x69510:
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r5 = tmp;
+                    if(r5 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69484;
+                        continue;
+                    }
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r4 = r4 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    r23 = r23 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6927c;
+                    run_69200(); return;
+                case 0x69548:
+                    r21 = r21 | 1;
+                case 0x6954c:
+                    r3 = 6 << 16;
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r3 = r3 + -2048;
+                    writePages[(r29+344)>>>12][((r29+344)>>>2)&0x3ff] = r3;
+                    r18 = r0 + 8;
+                    r20 = r0 + 3;
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x693b4;
+                        run_69200(); return;
+                    }
+                case 0x6956c:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6957c;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x6957c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x693b4;
+                        run_69200(); return;
+                    }
+                case 0x69584:
+                    r3 = readPages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x695a8;
+                        continue;
+                    }
+                    addr=r30+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    r2 = r2 & 64;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69484;
+                        continue;
+                    }
+                case 0x695a8:
+                    r2 = r0 + -1;
+                case 0x695ac:
+                    r31 = readPages[(r29+412)>>>12][((r29+412)>>>2)&0x3ff];
+                    r30 = readPages[(r29+408)>>>12][((r29+408)>>>2)&0x3ff];
+                    r23 = readPages[(r29+404)>>>12][((r29+404)>>>2)&0x3ff];
+                    r22 = readPages[(r29+400)>>>12][((r29+400)>>>2)&0x3ff];
+                    r21 = readPages[(r29+396)>>>12][((r29+396)>>>2)&0x3ff];
+                    r20 = readPages[(r29+392)>>>12][((r29+392)>>>2)&0x3ff];
+                    r19 = readPages[(r29+388)>>>12][((r29+388)>>>2)&0x3ff];
+                    r18 = readPages[(r29+384)>>>12][((r29+384)>>>2)&0x3ff];
+                    r17 = readPages[(r29+380)>>>12][((r29+380)>>>2)&0x3ff];
+                    r16 = readPages[(r29+376)>>>12][((r29+376)>>>2)&0x3ff];
+                    r29 = r29 + 416;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x695e0:
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x695ec;
+                        continue;
+                    }
+                    r22 = r0 + -1;
+                case 0x695ec:
+                    r21 = r21 & 16;
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69a10;
+                        run_69a00(); return;
+                    }
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r21 = r0 + r0;
+                case 0x69600:
+                    pc=0x69600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_69600() throws ExecutionException { /* 0x69600 - 0x69800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x69600:
+                    r10 = r29 + 24;
+                case 0x69604:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r10 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6968c;
+                        continue;
+                    }
+                case 0x69620:
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r4 = r4 + -1;
+                    r21 = r21 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    if(r22 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6946c;
+                        run_69400(); return;
+                    }
+                    if(r4 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69604;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    writePages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x6965c;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x6965c:
+                    r10 = readPages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6946c;
+                        run_69400(); return;
+                    }
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r10 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69620;
+                        continue;
+                    }
+                case 0x6968c:
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69484;
+                        run_69400(); return;
+                    }
+                    r23 = r23 + r21;
+                    /* Next insn is delay slot */ 
+                    pc=0x69470;
+                    run_69400(); return;
+                case 0x696a0:
+                    r2 = r22 + -1;
+                    r2 = (r2&0xffffffffL) < (39&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69a00;
+                        run_69a00(); return;
+                    }
+                    r13 = r0 + r0;
+                case 0x696b4:
+                    r11 = r29 + 280;
+                    r2 = 7 << 16;
+                    r10 = r21 | 3456;
+                    r12 = r0 + r0;
+                    r21 = r11 + r0;
+                    r14 = r0 + 512;
+                    r7 = r2 + 5372;
+                case 0x696d0:
+                    r6 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r6+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r2 = r4 + -43;
+                    r2 = r2 & 255;
+                    r5 = (r2&0xffffffffL) < (78&0xffffffffL) ? 1 : 0;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69898;
+                        run_69800(); return;
+                    }
+                    r3 = 7 << 16;
+                    r2 = r2 << 2;
+                    r3 = r3 + 5060;
+                    r2 = r3 + r2;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=r2;
+                    return;
+                case 0x69714:
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x697b0;
+                        continue;
+                    }
+                    r2 = r21 & 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x697c0;
+                        continue;
+                    }
+                case 0x69728:
+                    r21 = r21 & 16;
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69c10;
+                        run_69c00(); return;
+                    }
+                    r5 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r21 = r0 + r0;
+                case 0x69740:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r5 + r4;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6946c;
+                        run_69400(); return;
+                    }
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    r4 = r4 + -1;
+                    r21 = r21 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    if(r22 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6946c;
+                        run_69400(); return;
+                    }
+                    if(r4 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69740;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x69798;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x69798:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6946c;
+                        run_69400(); return;
+                    }
+                    r5 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x69740;
+                    continue;
+                case 0x697b0:
+                    r2 = r21 & 1;
+                    r22 = r0 + -1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69728;
+                        continue;
+                    }
+                case 0x697c0:
+                    r4 = r29 + 320;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    r20 = r21 & 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x697d8;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x697d8:
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69ed0;
+                        run_69e00(); return;
+                    }
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r21 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r3;
+                case 0x697f4:
+                    r6 = r0 + r0;
+                case 0x697f8:
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r4 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                case 0x69800:
+                    pc=0x69800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_69800() throws ExecutionException { /* 0x69800 - 0x69a00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x69800:
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r4 + r2;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r2 & 8;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69828;
+                        continue;
+                    }
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69ff0;
+                        run_69e00(); return;
+                    }
+                case 0x69828:
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6927c;
+                        run_69200(); return;
+                    }
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r0;
+                case 0x69834:
+                    r3 = readPages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x6927c;
+                    run_69200(); return;
+                case 0x6984c:
+                    r2 = r10 & 1536;
+                    if(r2 != r14) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69898;
+                        continue;
+                    }
+                    r2 = r0 + -513;
+                    r10 = r10 & r2;
+                    r10 = r10 | 1280;
+                    r18 = r0 + 16;
+                case 0x69868:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    addr=r21+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r2 + -1;
+                    r21 = r21 + 1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69994;
+                        continue;
+                    }
+                case 0x69884:
+                    r6 = r6 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r6;
+                case 0x6988c:
+                    r22 = r22 + -1;
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x696d0;
+                        run_69600(); return;
+                    }
+                case 0x69898:
+                    r2 = r10 & 256;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x698b8;
+                        continue;
+                    }
+                    r2 = ((r11 & 0xffffffffL) < (r21 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69f3c;
+                        run_69e00(); return;
+                    }
+                case 0x698b0:
+                    if(r21 == r11) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69484;
+                        run_69400(); return;
+                    }
+                case 0x698b8:
+                    r2 = r10 & 16;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69e04;
+                        run_69e00(); return;
+                    }
+                case 0x698c4:
+                    r11 = r21 - r11;
+                    r12 = r11 + r12;
+                    r23 = r23 + r12;
+                    /* Next insn is delay slot */ 
+                    pc=0x6927c;
+                    run_69200(); return;
+                case 0x698d8:
+                    r2 = r18 < 11 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69898;
+                        continue;
+                    }
+                    r2 = r0 + -2945;
+                    r10 = r10 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x69868;
+                    continue;
+                case 0x698f4:
+                    r2 = r18 << 1;
+                    r2 = r2 + r7;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r18 = tmp;
+                    r2 = r18 < 9 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69898;
+                        continue;
+                    }
+                    r2 = r0 + -2945;
+                    r10 = r10 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x69868;
+                    continue;
+                case 0x69920:
+                    r2 = r18 << 1;
+                    r2 = r2 + r7;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r18 = tmp;
+                    r2 = r0 + -2945;
+                    r10 = r10 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x69868;
+                    continue;
+                case 0x6993c:
+                    r2 = r10 & 2048;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69868;
+                        continue;
+                    }
+                    if(r18 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69958;
+                        continue;
+                    }
+                    r10 = r10 | 512;
+                    r18 = r0 + 8;
+                case 0x69958:
+                    r2 = r10 & 1024;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69ec0;
+                        run_69e00(); return;
+                    }
+                    r2 = r0 + -897;
+                    r10 = r10 & r2;
+                    if(r13 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6997c;
+                        continue;
+                    }
+                    r13 = r13 + -1;
+                    r22 = r22 + 1;
+                case 0x6997c:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r12 = r12 + 1;
+                    r2 = r2 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r2;
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69884;
+                        continue;
+                    }
+                case 0x69994:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    writePages[(r29+360)>>>12][((r29+360)>>>2)&0x3ff] = r7;
+                    writePages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff] = r10;
+                    writePages[(r29+368)>>>12][((r29+368)>>>2)&0x3ff] = r11;
+                    writePages[(r29+364)>>>12][((r29+364)>>>2)&0x3ff] = r12;
+                    writePages[(r29+352)>>>12][((r29+352)>>>2)&0x3ff] = r13;
+                    writePages[(r29+356)>>>12][((r29+356)>>>2)&0x3ff] = r14;
+                    /* Next insn is delay slot */ 
+                    r31=0x699bc;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x699bc:
+                    r7 = readPages[(r29+360)>>>12][((r29+360)>>>2)&0x3ff];
+                    r10 = readPages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff];
+                    r11 = readPages[(r29+368)>>>12][((r29+368)>>>2)&0x3ff];
+                    r12 = readPages[(r29+364)>>>12][((r29+364)>>>2)&0x3ff];
+                    r13 = readPages[(r29+352)>>>12][((r29+352)>>>2)&0x3ff];
+                    r14 = readPages[(r29+356)>>>12][((r29+356)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6988c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x69898;
+                    continue;
+                case 0x699e4:
+                    r2 = r10 & 128;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69898;
+                        continue;
+                    }
+                    r2 = r0 + -129;
+                    r10 = r10 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x69868;
+                    continue;
+                case 0x69a00:
+                    pc=0x69a00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_69a00() throws ExecutionException { /* 0x69a00 - 0x69c00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x69a00:
+                    r13 = r22 + -39;
+                    r22 = r0 + 39;
+                    /* Next insn is delay slot */ 
+                    pc=0x696b4;
+                    run_69600(); return;
+                case 0x69a10:
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r10 = r29 + 24;
+                    r3 = r3 + 4;
+                    writePages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r21 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r20 = r21 + r0;
+                case 0x69a34:
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r10 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r4 = tmp;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69abc;
+                        continue;
+                    }
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r20 = r20 + 1;
+                    r4 = r4 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    r4 = r2 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r22 = r22 + -1;
+                    addr=r20+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69abc;
+                        continue;
+                    }
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69a34;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    writePages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x69aa8;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x69aa8:
+                    r10 = readPages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69a34;
+                        continue;
+                    }
+                    if(r21 == r20) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        run_69400(); return;
+                    }
+                case 0x69abc:
+                    r21 = r20 - r21;
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69484;
+                        run_69400(); return;
+                    }
+                    r3 = readPages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff];
+                    addr=r20+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r3 = r3 + 1;
+                    writePages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff];
+                    r23 = r23 + r21;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x69470;
+                    run_69400(); return;
+                case 0x69aec:
+                    r3 = 6 << 16;
+                    r3 = r3 + -2048;
+                    writePages[(r29+344)>>>12][((r29+344)>>>2)&0x3ff] = r3;
+                    r18 = r0 + 10;
+                    r20 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x693a4;
+                    run_69200(); return;
+                case 0x69b08:
+                    r20 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x693a4;
+                    run_69200(); return;
+                case 0x69b14:
+                    r21 = r21 | 544;
+                case 0x69b18:
+                    r3 = 6 << 16;
+                    r3 = r3 + -2048;
+                    writePages[(r29+344)>>>12][((r29+344)>>>2)&0x3ff] = r3;
+                    r18 = r0 + 16;
+                    r20 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x693a4;
+                    run_69200(); return;
+                case 0x69b34:
+                    r2 = r21 & 16;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6927c;
+                        run_69200(); return;
+                    }
+                    r2 = r21 & 4;
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69fd8;
+                        run_69e00(); return;
+                    }
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r23&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x6927c;
+                    run_69200(); return;
+                case 0x69b68:
+                    r21 = r21 | 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x69340;
+                    run_69200(); return;
+                case 0x69b74:
+                    r3 = 4 << 16;
+                    r3 = r3 + 12800;
+                    writePages[(r29+344)>>>12][((r29+344)>>>2)&0x3ff] = r3;
+                    r18 = r0 + r0;
+                    r20 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x693a4;
+                    run_69200(); return;
+                case 0x69b90:
+                    r21 = r21 | 4;
+                    /* Next insn is delay slot */ 
+                    pc=0x69340;
+                    run_69200(); return;
+                case 0x69b9c:
+                    r21 = r21 | 64;
+                    r20 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x693a4;
+                    run_69200(); return;
+                case 0x69bac:
+                    r5 = r16 + r0;
+                    r4 = r29 + 24;
+                    /* Next insn is delay slot */ 
+                    r31=0x69bbc;
+                    pc=0x66800;
+                    run_66800(); return;
+                case 0x69bbc:
+                    r16 = r2 + r0;
+                    r21 = r21 | 64;
+                    r20 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x693a4;
+                    run_69200(); return;
+                case 0x69bd0:
+                    r21 = r21 | 512;
+                    /* Next insn is delay slot */ 
+                    pc=0x69b18;
+                    continue;
+                case 0x69bdc:
+                    r21 = r21 | 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x69340;
+                    run_69200(); return;
+                case 0x69be8:
+                    r21 = r21 | 16;
+                    /* Next insn is delay slot */ 
+                    pc=0x69340;
+                    run_69200(); return;
+                case 0x69bf4:
+                    r2 = r22 << 1;
+                    r9 = r22 << 3;
+                    r2 = r2 + r9;
+                case 0x69c00:
+                    pc=0x69c00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_69c00() throws ExecutionException { /* 0x69c00 - 0x69e00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x69c00:
+                    r4 = r4 + -48;
+                    r22 = r4 + r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x69340;
+                    run_69200(); return;
+                case 0x69c10:
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r20 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r21 = r20 + r0;
+                case 0x69c34:
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r5 = readPages[(r28+-31060)>>>12][((r28+-31060)>>>2)&0x3ff];
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r5 + r4;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r4 & 8;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69cb0;
+                        continue;
+                    }
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r21 = r21 + 1;
+                    r4 = r4 + -1;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    r4 = r2 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r22 = r22 + -1;
+                    addr=r21+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r2&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r22 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69cb0;
+                        continue;
+                    }
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69c34;
+                        continue;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x69ca8;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x69ca8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69c34;
+                        continue;
+                    }
+                case 0x69cb0:
+                    r3 = readPages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff];
+                    r6 = r21 - r20;
+                    r3 = r3 + 1;
+                    writePages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff];
+                    addr=r21+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r23 = r23 + r6;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x6927c;
+                    run_69200(); return;
+                case 0x69cd8:
+                    r4 = r29 + 320;
+                    r5 = r0 + r0;
+                    r6 = r0 + 8;
+                    r21 = r21 & 16;
+                    /* Next insn is delay slot */ 
+                    r31=0x69cf0;
+                    pc=0x48fec;
+                    run_48e00(); return;
+                case 0x69cf0:
+                    writePages[(r29+348)>>>12][((r29+348)>>>2)&0x3ff] = r21;
+                    if(r21 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69f08;
+                        run_69e00(); return;
+                    }
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    writePages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r3;
+                case 0x69d20:
+                    r21 = r0 + r0;
+                case 0x69d24:
+                    /* Next insn is delay slot */ 
+                    r31=0x69d2c;
+                    pc=0x5a800;
+                    run_5a800(); return;
+                case 0x69d2c:
+                    if(r2 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        run_69400(); return;
+                    }
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r3 = r29 + 24;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r6 = r3 + r21;
+                    addr=r6+256;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    r4 = r4 + -1;
+                    r2 = r29 + 320;
+                    r20 = r21 + 1;
+                    r5 = readPages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff];
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    r6 = r29 + 280;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = r17 + r0;
+                    r7 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x69d80;
+                    pc=0x66000;
+                    run_66000(); return;
+                case 0x69d80:
+                    r3 = r0 + -1;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        run_69400(); return;
+                    }
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69f80;
+                        run_69e00(); return;
+                    }
+                    r3 = readPages[(r29+348)>>>12][((r29+348)>>>2)&0x3ff];
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69db0;
+                        continue;
+                    }
+                    r3 = readPages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r0;
+                case 0x69db0:
+                    r3 = readPages[(r29+348)>>>12][((r29+348)>>>2)&0x3ff];
+                    r23 = r23 + r20;
+                    r22 = r22 + -1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69f98;
+                        run_69e00(); return;
+                    }
+                    r3 = readPages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff];
+                    r21 = r0 + r0;
+                    r3 = r3 + 4;
+                    writePages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff] = r3;
+                case 0x69dd4:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69f14;
+                        run_69e00(); return;
+                    }
+                case 0x69de4:
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69d24;
+                        continue;
+                    }
+                case 0x69dec:
+                    r3 = readPages[(r29+348)>>>12][((r29+348)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69834;
+                        run_69800(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6927c;
+                    run_69200(); return;
+                case 0x69e00:
+                    pc=0x69e00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_69e00() throws ExecutionException { /* 0x69e00 - 0x6a000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x69e00:
+                case 0x69e04:
+                    r3 = readPages[(r29+344)>>>12][((r29+344)>>>2)&0x3ff];
+                    addr=r21+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r0&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = r17 + r0;
+                    r5 = r11 + r0;
+                    writePages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff] = r10;
+                    writePages[(r29+368)>>>12][((r29+368)>>>2)&0x3ff] = r11;
+                    writePages[(r29+364)>>>12][((r29+364)>>>2)&0x3ff] = r12;
+                    r6 = r0 + r0;
+                    r7 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r3;
+                    r31=0x69e30;
+                    return;
+                case 0x69e30:
+                    r10 = readPages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff];
+                    r11 = readPages[(r29+368)>>>12][((r29+368)>>>2)&0x3ff];
+                    r4 = r10 & 32;
+                    r12 = readPages[(r29+364)>>>12][((r29+364)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69edc;
+                        continue;
+                    }
+                case 0x69e48:
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r3;
+                case 0x69e60:
+                    r3 = readPages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x698c4;
+                    run_69800(); return;
+                case 0x69e78:
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    r5 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r6 = r0 + 1;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r30;
+                    r7 = r22 + r0;
+                    r21 = r3 + 4;
+                    /* Next insn is delay slot */ 
+                    r31=0x69e9c;
+                    pc=0x69000;
+                    run_69000(); return;
+                case 0x69e9c:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        run_69400(); return;
+                    }
+                    r3 = readPages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff];
+                    r23 = r2 + r23;
+                    r3 = r3 + 1;
+                    writePages[(r29+340)>>>12][((r29+340)>>>2)&0x3ff] = r3;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r21;
+                    /* Next insn is delay slot */ 
+                    pc=0x6927c;
+                    run_69200(); return;
+                case 0x69ec0:
+                    r2 = r0 + -1409;
+                    r10 = r10 & r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x69868;
+                    run_69800(); return;
+                case 0x69ed0:
+                    r21 = r29 + 328;
+                    /* Next insn is delay slot */ 
+                    pc=0x697f4;
+                    run_69600(); return;
+                case 0x69edc:
+                    r4 = r10 & 4;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69e48;
+                        continue;
+                    }
+                    r3 = readPages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff];
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x69e60;
+                    continue;
+                case 0x69f08:
+                    writePages[(r29+336)>>>12][((r29+336)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x69d20;
+                    run_69c00(); return;
+                case 0x69f14:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x69f24;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x69f24:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69de4;
+                        run_69c00(); return;
+                    }
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69dec;
+                        run_69c00(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x69584;
+                    run_69400(); return;
+                case 0x69f3c:
+                    addr=r21+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    if((tmp&0x80)!=0) tmp |= 0xffffff00; /* sign extend */
+                    r5 = tmp;
+                    r7 = r21 + -1;
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+360)>>>12][((r29+360)>>>2)&0x3ff] = r7;
+                    writePages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff] = r10;
+                    writePages[(r29+368)>>>12][((r29+368)>>>2)&0x3ff] = r11;
+                    writePages[(r29+364)>>>12][((r29+364)>>>2)&0x3ff] = r12;
+                    /* Next insn is delay slot */ 
+                    r31=0x69f64;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x69f64:
+                    r7 = readPages[(r29+360)>>>12][((r29+360)>>>2)&0x3ff];
+                    r12 = readPages[(r29+364)>>>12][((r29+364)>>>2)&0x3ff];
+                    r21 = r7 + r0;
+                    r11 = readPages[(r29+368)>>>12][((r29+368)>>>2)&0x3ff];
+                    r10 = readPages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x698b0;
+                    run_69800(); return;
+                case 0x69f80:
+                    r3 = r0 + -2;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69db0;
+                        run_69c00(); return;
+                    }
+                    r21 = r20 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x69dd4;
+                    run_69c00(); return;
+                case 0x69f98:
+                    r21 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x69dd4;
+                    run_69c00(); return;
+                case 0x69fa4:
+                    if(r21 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        run_69400(); return;
+                    }
+                    r23 = r23 + r21;
+                    /* Next insn is delay slot */ 
+                    pc=0x69470;
+                    run_69400(); return;
+                case 0x69fb8:
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x69fc8;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x69fc8:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69510;
+                        run_69400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x69584;
+                    run_69400(); return;
+                case 0x69fd8:
+                    r2 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r23;
+                    writePages[(r29+428)>>>12][((r29+428)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x6927c;
+                    run_69200(); return;
+                case 0x69ff0:
+                    writePages[(r29+352)>>>12][((r29+352)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x69ffc;
+                    pc=0x5a800;
+                    run_5a800(); return;
+                case 0x69ffc:
+                    r6 = readPages[(r29+352)>>>12][((r29+352)>>>2)&0x3ff];
+                case 0x6a000:
+                    pc=0x6a000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6a000() throws ExecutionException { /* 0x6a000 - 0x6a200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6a000:
+                    if(r2 == r6) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        run_69400(); return;
+                    }
+                    r2 = readPages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff];
+                    r3 = r29 + 24;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r10 = r6 + 1;
+                    r6 = r3 + r6;
+                    addr=r6+256;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r4 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r30+0)>>>12][((r30+0)>>>2)&0x3ff] = r2;
+                    r4 = r4 + -1;
+                    r2 = r29 + 320;
+                    writePages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff] = r4;
+                    r7 = r10 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r2;
+                    r4 = r17 + r0;
+                    r5 = r21 + r0;
+                    r6 = r29 + 280;
+                    writePages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a05c;
+                    pc=0x66000;
+                    run_66000(); return;
+                case 0x6a05c:
+                    r3 = r0 + -1;
+                    r10 = readPages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff];
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        run_69400(); return;
+                    }
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a0c4;
+                        continue;
+                    }
+                    r3 = r0 + -2;
+                    r6 = r10 + r0;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a154;
+                        continue;
+                    }
+                case 0x6a084:
+                    r2 = readPages[(r30+4)>>>12][((r30+4)>>>2)&0x3ff];
+                    if(r2 > 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x697f8;
+                        run_69600(); return;
+                    }
+                    r4 = r17 + r0;
+                    r5 = r30 + r0;
+                    writePages[(r29+352)>>>12][((r29+352)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a0a8;
+                    pc=0x68e00;
+                    run_68e00(); return;
+                case 0x6a0a8:
+                    r6 = readPages[(r29+352)>>>12][((r29+352)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x697f8;
+                        run_69600(); return;
+                    }
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69584;
+                        run_69400(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x69828;
+                    run_69800(); return;
+                case 0x6a0c4:
+                    writePages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff] = r0;
+                    r4 = r0 + r0;
+                case 0x6a0cc:
+                    writePages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a0d8;
+                    pc=0x65e00;
+                    run_65e00(); return;
+                case 0x6a0d8:
+                    r10 = readPages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a128;
+                        continue;
+                    }
+                    if(r10 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x69828;
+                        run_69800(); return;
+                    }
+                case 0x6a0ec:
+                    r10 = r10 + -1;
+                    r3 = r29 + 280;
+                    r2 = r3 + r10;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r5 = tmp;
+                    r4 = r17 + r0;
+                    r6 = r30 + r0;
+                    writePages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff] = r10;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a110;
+                    pc=0x68c00;
+                    run_68c00(); return;
+                case 0x6a110:
+                    r10 = readPages[(r29+372)>>>12][((r29+372)>>>2)&0x3ff];
+                    if(r10 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a0ec;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x69828;
+                    run_69800(); return;
+                case 0x6a128:
+                    r23 = r23 + r10;
+                    r22 = r22 + -1;
+                    if(r20 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a148;
+                        continue;
+                    }
+                    r21 = r21 + 4;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6a084;
+                    continue;
+                case 0x6a148:
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6a084;
+                    continue;
+                case 0x6a154:
+                    r4 = readPages[(r21+0)>>>12][((r21+0)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x6a0cc;
+                    continue;
+                case 0x6a200:
+                    pc=0x6a200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6a200() throws ExecutionException { /* 0x6a200 - 0x6a400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6a200:
+                    r29 = r29 + -40;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r16 = r5 + r0;
+                    r5 = readPages[(r5+48)>>>12][((r5+48)>>>2)&0x3ff];
+                    r2 = r16 + 64;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r31;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r20;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r19;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a2a0;
+                        continue;
+                    }
+                    r18 = readPages[(r16+52)>>>12][((r16+52)>>>2)&0x3ff];
+                    r19 = r18 << 1;
+                    r6 = r19 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a248;
+                    pc=0x40800;
+                    run_40800(); return;
+                case 0x6a248:
+                    r17 = r2 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a30c;
+                        continue;
+                    }
+                    r20 = r2 + r18;
+                    r4 = r20 + r0;
+                    r5 = r2 + r0;
+                    r6 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a26c;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x6a26c:
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r20;
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r17;
+                    writePages[(r16+52)>>>12][((r16+52)>>>2)&0x3ff] = r19;
+                    r2 = r0 + r0;
+                case 0x6a27c:
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6a2a0:
+                    r5 = r0 + 1024;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a2ac;
+                    pc=0x3ec00;
+                    run_3ec00(); return;
+                case 0x6a2ac:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a30c;
+                        continue;
+                    }
+                    r3 = r0 + 1024;
+                    writePages[(r16+52)>>>12][((r16+52)>>>2)&0x3ff] = r3;
+                    addr=r16+66;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r2;
+                    addr=r2+1023;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r16+65;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r2 + 1021;
+                    addr=r2+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r16+64;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r3&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r31 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r20 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r19 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r2 = r0 + r0;
+                    r29 = r29 + 40;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6a30c:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6a27c;
+                    continue;
+                case 0x6a400:
+                    pc=0x6a400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6a400() throws ExecutionException { /* 0x6a400 - 0x6a600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6a400:
+                    r29 = r29 + -32;
+                    r2 = r0 + -1;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r18;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r31;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r17;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r16;
+                    r18 = r5 + r0;
+                    if(r5 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a52c;
+                        continue;
+                    }
+                    r17 = r4 + r0;
+                    r16 = r6 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a444;
+                        continue;
+                    }
+                    r2 = readPages[(r4+56)>>>12][((r4+56)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a538;
+                        continue;
+                    }
+                case 0x6a444:
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    if((tmp&0x8000)!=0) tmp |= 0xffff0000; /* sign extend */
+                    r2 = tmp;
+                    r3 = r2 & 8192;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a46c;
+                        continue;
+                    }
+                    r4 = readPages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff];
+                    r3 = r0 + -8193;
+                    r3 = r4 & r3;
+                    r2 = r2 | 8192;
+                    writePages[(r16+100)>>>12][((r16+100)>>>2)&0x3ff] = r3;
+                case 0x6a46c:
+                    r3 = r0 + -33;
+                    r2 = r2 & r3;
+                    r3 = r2 & 65535;
+                    r4 = r3 & 4;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a4a8;
+                        continue;
+                    }
+                    r4 = r3 & 16;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a52c;
+                        continue;
+                    }
+                    r3 = r3 & 8;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a548;
+                        continue;
+                    }
+                    r2 = r2 | 4;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                case 0x6a4a8:
+                    r2 = readPages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff];
+                    r18 = r18 & 255;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a588;
+                        continue;
+                    }
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = readPages[(r16+52)>>>12][((r16+52)>>>2)&0x3ff];
+                    r2 = r3 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a514;
+                        continue;
+                    }
+                case 0x6a4d0:
+                    r2 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    r3 = r2 + -1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r2 = r2 + 1;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    r2 = r18 + r0;
+                case 0x6a4f8:
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6a514:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a524;
+                    pc=0x6a200;
+                    run_6a200(); return;
+                case 0x6a524:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a4d0;
+                        continue;
+                    }
+                case 0x6a52c:
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6a4f8;
+                    continue;
+                case 0x6a538:
+                    /* Next insn is delay slot */ 
+                    r31=0x6a540;
+                    pc=0x3a600;
+                    run_3a600(); return;
+                case 0x6a540:
+                    /* Next insn is delay slot */ 
+                    pc=0x6a444;
+                    continue;
+                case 0x6a548:
+                    r4 = r17 + r0;
+                    r5 = r16 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6a558;
+                    pc=0x39800;
+                    run_39800(); return;
+                case 0x6a558:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a52c;
+                        continue;
+                    }
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&2)<<3)) & 0xffff;
+                    r2 = tmp;
+                    writePages[(r16+8)>>>12][((r16+8)>>>2)&0x3ff] = r0;
+                    r2 = r2 & 65527;
+                    r2 = r2 << 16;
+                    r2 = r2 >> 16;
+                    r2 = r2 | 4;
+                    writePages[(r16+24)>>>12][((r16+24)>>>2)&0x3ff] = r0;
+                    addr=r16+12;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&(0xffff<<((addr&2)<<3)))|((r2&0xffff)<<(((~addr)&2)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x6a4a8;
+                    continue;
+                case 0x6a588:
+                    r2 = readPages[(r16+16)>>>12][((r16+16)>>>2)&0x3ff];
+                    r3 = readPages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a5b4;
+                        continue;
+                    }
+                    r2 = ((r2 & 0xffffffffL) < (r3 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a5b4;
+                        continue;
+                    }
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r18) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6a604;
+                        run_6a600(); return;
+                    }
+                case 0x6a5b4:
+                    r2 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    addr=r16+66;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r18&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    writePages[(r16+60)>>>12][((r16+60)>>>2)&0x3ff] = r2;
+                    r2 = r16 + 64;
+                    writePages[(r16+48)>>>12][((r16+48)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 3;
+                    writePages[(r16+52)>>>12][((r16+52)>>>2)&0x3ff] = r2;
+                    r31 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r2 = r16 + 66;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r2;
+                    writePages[(r16+56)>>>12][((r16+56)>>>2)&0x3ff] = r3;
+                    r2 = r18 + r0;
+                    r17 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r18 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r16 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r29 = r29 + 32;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6a600:
+                    pc=0x6a600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6a600() throws ExecutionException { /* 0x6a600 - 0x6a800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6a600:
+                case 0x6a604:
+                    r3 = r3 + -1;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r3;
+                    r3 = readPages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff];
+                    r3 = r3 + 1;
+                    writePages[(r16+4)>>>12][((r16+4)>>>2)&0x3ff] = r3;
+                    /* Next insn is delay slot */ 
+                    pc=0x6a4f8;
+                    run_6a400(); return;
+                case 0x6a800:
+                    pc=0x6a800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6a800() throws ExecutionException { /* 0x6a800 - 0x6aa00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6a800:
+                    r2 = r4 + r0;
+                    r4 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r6 = r5 + r0;
+                    r5 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6a400;
+                    run_6a400(); return;
+                case 0x6aa00:
+                    pc=0x6aa00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6aa00() throws ExecutionException { /* 0x6aa00 - 0x6ac00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6aa00:
+                    r29 = r29 + -64;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r18;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r17;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    r16 = r4 + r0;
+                    r17 = r7 + r0;
+                    r18 = readPages[(r28+-30856)>>>12][((r28+-30856)>>>2)&0x3ff];
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6aa8c;
+                        continue;
+                    }
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r5;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x6aa38;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x6aa38:
+                    r5 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r6 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r17;
+                    r4 = r16 + r0;
+                    r7 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r18;
+                    r31=0x6aa54;
+                    return;
+                case 0x6aa54:
+                    r3 = r0 + -1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6aa70;
+                        continue;
+                    }
+                    r2 = r0 + 138;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r0;
+                    writePages[(r16+0)>>>12][((r16+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                case 0x6aa70:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r18 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r17 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r16 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6aa8c:
+                    /* Next insn is delay slot */ 
+                    r31=0x6aa94;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x6aa94:
+                    r7 = r2 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r17;
+                    r4 = r16 + r0;
+                    r5 = r29 + 24;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r18;
+                    r31=0x6aab0;
+                    return;
+                case 0x6aab0:
+                    /* Next insn is delay slot */ 
+                    pc=0x6aa54;
+                    continue;
+                case 0x6ac00:
+                    pc=0x6ac00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6ac00() throws ExecutionException { /* 0x6ac00 - 0x6ae00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6ac00:
+                    r29 = r29 + -64;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r17;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r16;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r31;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r20;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r19;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r18;
+                    r16 = r4 + r0;
+                    r17 = r6 + r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6aca0;
+                        continue;
+                    }
+                    r20 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r18 = r5 + r0;
+                    r19 = readPages[(r28+-30856)>>>12][((r28+-30856)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x6ac40;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x6ac40:
+                    r7 = r2 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r17;
+                    r4 = r20 + r0;
+                    r5 = r16 + r0;
+                    r6 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r19;
+                    r31=0x6ac5c;
+                    return;
+                case 0x6ac5c:
+                    r3 = r0 + -1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6ac7c;
+                        continue;
+                    }
+                    r2 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r3 = r0 + 138;
+                    writePages[(r17+0)>>>12][((r17+0)>>>2)&0x3ff] = r0;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r2 = r0 + -1;
+                case 0x6ac7c:
+                    r31 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r20 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r19 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r18 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r17 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r16 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r29 = r29 + 64;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6aca0:
+                    r18 = readPages[(r28+-31072)>>>12][((r28+-31072)>>>2)&0x3ff];
+                    r16 = readPages[(r28+-30856)>>>12][((r28+-30856)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x6acb0;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x6acb0:
+                    r7 = r2 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r17;
+                    r4 = r18 + r0;
+                    r5 = r29 + 24;
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r16;
+                    r31=0x6accc;
+                    return;
+                case 0x6accc:
+                    /* Next insn is delay slot */ 
+                    pc=0x6ac5c;
+                    continue;
+                case 0x6ae00:
+                    pc=0x6ae00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6ae00() throws ExecutionException { /* 0x6ae00 - 0x6b000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6ae00:
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6ae24;
+                        continue;
+                    }
+                    r2 = (r6&0xffffffffL) < (256&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6ae30;
+                        continue;
+                    }
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r6&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    r2 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6ae24:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6ae30:
+                    r2 = r0 + 138;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6b000:
+                    pc=0x6b000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6b000() throws ExecutionException { /* 0x6b000 - 0x6b200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6b000:
+                    r29 = r29 + -56;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r31;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r17;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r16;
+                    r17 = r7 + r0;
+                    r16 = readPages[(r28+-30856)>>>12][((r28+-30856)>>>2)&0x3ff];
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r4;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r5;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x6b02c;
+                    pc=0x5a600;
+                    run_5a600(); return;
+                case 0x6b02c:
+                    r4 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r6 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r17;
+                    r7 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=r16;
+                    r31=0x6b048;
+                    return;
+                case 0x6b048:
+                    r31 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r17 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r16 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r29 = r29 + 56;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6b200:
+                    pc=0x6b200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6b200() throws ExecutionException { /* 0x6b200 - 0x6b400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6b200:
+                    r7 = readPages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff];
+                    r2 = r5 >> 5;
+                    r6 = r2 < r7 ? 1 : 0;
+                    r3 = r4 + 20;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b2bc;
+                        continue;
+                    }
+                    r7 = r7 << 2;
+                    r2 = r2 << 2;
+                    r5 = r5 & 31;
+                    r7 = r3 + r7;
+                    r11 = r3 + r2;
+                    if(r5 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b2cc;
+                        continue;
+                    }
+                    r2 = r11 + 4;
+                    r8 = readPages[(r11+0)>>>12][((r11+0)>>>2)&0x3ff];
+                    r10 = r0 + 32;
+                    r6 = ((r2 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    r10 = r10 - r5;
+                    r8 = r8 >>> (r5&0x1f);
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b324;
+                        continue;
+                    }
+                    r6 = r3 + r0;
+                case 0x6b258:
+                    r9 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r6 = r6 + 4;
+                    r9 = r9 << (r10&0x1f);
+                    r8 = r8 | r9;
+                    r2 = r2 + 4;
+                    writePages[(r6+-4)>>>12][((r6+-4)>>>2)&0x3ff] = r8;
+                    r8 = readPages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff];
+                    r9 = ((r2 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    r8 = r8 >>> (r5&0x1f);
+                    if(r9 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b258;
+                        continue;
+                    }
+                    r2 = r7 - r11;
+                    r2 = r2 + -5;
+                    r2 = r2 >>> 2;
+                    r2 = r2 + 1;
+                    r2 = r2 << 2;
+                    r2 = r3 + r2;
+                case 0x6b29c:
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r8;
+                    if(r8 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b2ac;
+                        continue;
+                    }
+                    r2 = r2 + 4;
+                case 0x6b2ac:
+                    r3 = r2 - r3;
+                    r3 = r3 >> 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b310;
+                    continue;
+                case 0x6b2bc:
+                    writePages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff] = r0;
+                case 0x6b2c0:
+                    writePages[(r4+20)>>>12][((r4+20)>>>2)&0x3ff] = r0;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6b2cc:
+                    r2 = ((r11 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b2bc;
+                        continue;
+                    }
+                    r2 = r11 + r0;
+                case 0x6b2dc:
+                    r2 = r2 + 4;
+                    r5 = readPages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff];
+                    r3 = r3 + 4;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r5;
+                    r5 = ((r2 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b2dc;
+                        continue;
+                    }
+                    r3 = ~(r0 | r11);
+                    r3 = r3 + r7;
+                    r3 = r3 >>> 2;
+                    r3 = r3 + 1;
+                    r3 = r3 << 2;
+                    r3 = r3 >> 2;
+                case 0x6b310:
+                    writePages[(r4+16)>>>12][((r4+16)>>>2)&0x3ff] = r3;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b2c0;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6b324:
+                    r2 = r3 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b29c;
+                    continue;
+                case 0x6b400:
+                    pc=0x6b400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6b400() throws ExecutionException { /* 0x6b400 - 0x6b600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6b400:
+                    r5 = 7 << 16;
+                    r2 = 7 << 16;
+                    r5 = r5 + 5425;
+                    r4 = r0 + 16;
+                    r3 = r0 + 48;
+                    r2 = r2 + 30712;
+                case 0x6b418:
+                    r3 = r2 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r4 = r4 + 1;
+                    r4 = r4 & 255;
+                    r5 = r5 + 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b418;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r5 = r5 + 5417;
+                    r4 = r0 + 26;
+                    r3 = r0 + 97;
+                case 0x6b448:
+                    r3 = r2 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r4 = r4 + 1;
+                    r4 = r4 & 255;
+                    r5 = r5 + 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b448;
+                        continue;
+                    }
+                    r5 = 7 << 16;
+                    r5 = r5 + 5409;
+                    r4 = r0 + 26;
+                    r3 = r0 + 65;
+                case 0x6b478:
+                    r3 = r2 + r3;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp&~(0xff000000>>>((addr&3)<<3)))|((r4&0xff)<<(((~addr)&3)<<3));
+                    writePages[(addr)>>>12][((addr)>>>2)&0x3ff] = tmp;
+                    addr=r5+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r4 = r4 + 1;
+                    r4 = r4 & 255;
+                    r5 = r5 + 1;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b478;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6b600:
+                    pc=0x6b600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6b600() throws ExecutionException { /* 0x6b600 - 0x6b800 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6b600:
+                    r29 = r29 + -88;
+                    writePages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff] = r31;
+                    writePages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff] = r21;
+                    writePages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff] = r20;
+                    writePages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff] = r19;
+                    writePages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff] = r18;
+                    writePages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff] = r17;
+                    writePages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff] = r4;
+                    r19 = r5 + r0;
+                    writePages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff] = r6;
+                    writePages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff] = r7;
+                    writePages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff] = r30;
+                    writePages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff] = r23;
+                    writePages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff] = r22;
+                    writePages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff] = r16;
+                    /* Next insn is delay slot */ 
+                    r31=0x6b644;
+                    pc=0x5ae00;
+                    run_5ae00(); return;
+                case 0x6b644:
+                    r17 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r4 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6b658;
+                    pc=0x10268;
+                    run_10200(); return;
+                case 0x6b658:
+                    r9 = 7 << 16;
+                    r18 = r2 + r0;
+                    r20 = r9 + 30712;
+                    r2 = r17 + r2;
+                    addr=r2+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r21 = tmp;
+                    addr=r20+48;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bb30;
+                        run_6ba00(); return;
+                    }
+                case 0x6b67c:
+                    r3 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    r2 = r0 + 48;
+                    addr=r3+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r23 = r3 + 2;
+                    if(r8 != r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6be30;
+                        run_6be00(); return;
+                    }
+                    r3 = r3 + 3;
+                    r22 = r0 + r0;
+                case 0x6b69c:
+                    r23 = r3 + r0;
+                    r3 = r3 + 1;
+                    addr=r3+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r8 = tmp;
+                    r22 = r22 + 1;
+                    if(r8 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b69c;
+                        continue;
+                    }
+                case 0x6b6b4:
+                    r8 = r20 + r8;
+                    addr=r8+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6baac;
+                        run_6ba00(); return;
+                    }
+                    addr=r23+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r7 = r0 + r0;
+                    r2 = r2 + r20;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r30 = r0 + r0;
+                case 0x6b6dc:
+                    r16 = r23 + r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b708;
+                        continue;
+                    }
+                case 0x6b6e8:
+                    r16 = r16 + 1;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r2 = r20 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b6e8;
+                        continue;
+                    }
+                case 0x6b708:
+                    r4 = r16 + r0;
+                    r5 = r17 + r0;
+                    r6 = r18 + r0;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r7;
+                    /* Next insn is delay slot */ 
+                    r31=0x6b720;
+                    pc=0x43000;
+                    run_43000(); return;
+                case 0x6b720:
+                    r7 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b7a8;
+                        continue;
+                    }
+                    if(r30 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6be6c;
+                        run_6be00(); return;
+                    }
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                case 0x6b738:
+                    r30 = r30 - r16;
+                    r30 = r30 << 2;
+                case 0x6b740:
+                    r3 = r0 + 80;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b7c0;
+                        continue;
+                    }
+                case 0x6b74c:
+                    r3 = r0 + 112;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b7c0;
+                        continue;
+                    }
+                case 0x6b758:
+                    r2 = r16 + r0;
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r2;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b868;
+                        run_6b800(); return;
+                    }
+                case 0x6b768:
+                    if(r22 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd74;
+                        run_6bc00(); return;
+                    }
+                    r2 = r0 + 6;
+                case 0x6b774:
+                    r31 = readPages[(r29+84)>>>12][((r29+84)>>>2)&0x3ff];
+                    r30 = readPages[(r29+80)>>>12][((r29+80)>>>2)&0x3ff];
+                    r23 = readPages[(r29+76)>>>12][((r29+76)>>>2)&0x3ff];
+                    r22 = readPages[(r29+72)>>>12][((r29+72)>>>2)&0x3ff];
+                    r21 = readPages[(r29+68)>>>12][((r29+68)>>>2)&0x3ff];
+                    r20 = readPages[(r29+64)>>>12][((r29+64)>>>2)&0x3ff];
+                    r19 = readPages[(r29+60)>>>12][((r29+60)>>>2)&0x3ff];
+                    r18 = readPages[(r29+56)>>>12][((r29+56)>>>2)&0x3ff];
+                    r17 = readPages[(r29+52)>>>12][((r29+52)>>>2)&0x3ff];
+                    r16 = readPages[(r29+48)>>>12][((r29+48)>>>2)&0x3ff];
+                    r29 = r29 + 88;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6b7a8:
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r30 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b738;
+                        continue;
+                    }
+                    r3 = r0 + 80;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b74c;
+                        continue;
+                    }
+                case 0x6b7c0:
+                    addr=r16+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r3 = r0 + 43;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd80;
+                        run_6bc00(); return;
+                    }
+                    r3 = r0 + 45;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bcfc;
+                        run_6bc00(); return;
+                    }
+                    r4 = r16 + 1;
+                    r6 = r0 + r0;
+                case 0x6b7e4:
+                    r2 = r20 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    r2 = r3 + -1;
+                    r2 = (r2&0xffffffffL) < (25&0xffffffffL) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b758;
+                        continue;
+                    }
+                case 0x6b800:
+                    pc=0x6b800;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6b800() throws ExecutionException { /* 0x6b800 - 0x6ba00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6b800:
+                    r2 = r4 + 1;
+                    r3 = r3 + -16;
+                    addr=r4+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b830;
+                    continue;
+                case 0x6b814:
+                    r5 = r3 << 1;
+                    r3 = r3 << 3;
+                    r3 = r5 + r3;
+                    r2 = r2 + 1;
+                    r3 = r3 + r4;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r3 = r3 + -16;
+                case 0x6b830:
+                    r4 = r4 + r20;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r5 = r4 + -1;
+                    r5 = (r5&0xffffffffL) < (25&0xffffffffL) ? 1 : 0;
+                    if(r5 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b814;
+                        continue;
+                    }
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b858;
+                        continue;
+                    }
+                    r3 = r0 - r3;
+                case 0x6b858:
+                    r30 = r30 + r3;
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r2;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b768;
+                        run_6b600(); return;
+                    }
+                case 0x6b868:
+                    r2 = r16 - r23;
+                    r2 = r2 + -1;
+                    r3 = r2 < 8 ? 1 : 0;
+                    r5 = r0 + r0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b894;
+                        continue;
+                    }
+                case 0x6b880:
+                    r2 = r2 >> 1;
+                    r3 = r2 < 8 ? 1 : 0;
+                    r5 = r5 + 1;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b880;
+                        continue;
+                    }
+                case 0x6b894:
+                    r4 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x6b8a0;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x6b8a0:
+                    r19 = r2 + 20;
+                    r22 = r2 + r0;
+                    r2 = ((r23 & 0xffffffffL) < (r16 & 0xffffffffL)) ? 1 : 0;
+                    r11 = r19 + r0;
+                    r8 = r0 + r0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b9a0;
+                        continue;
+                    }
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r14 = r0 + 1;
+                    r3 = r0 + r0;
+                    r14 = r14 - r18;
+                    r12 = r0 + 32;
+                    r7 = r16 + -1;
+                    if(r6 == r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b92c;
+                        continue;
+                    }
+                case 0x6b8dc:
+                    if(r3 == r12) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6ba90;
+                        run_6ba00(); return;
+                    }
+                    r2 = r3 + r0;
+                    r3 = r3 + 4;
+                case 0x6b8ec:
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r4 = tmp;
+                    r4 = r20 + r4;
+                    addr=r4+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r6 = r6 & 15;
+                    r6 = r6 << (r2&0x1f);
+                    r8 = r8 | r6;
+                    r6 = ((r23 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    if(r6 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b9a0;
+                        continue;
+                    }
+                case 0x6b918:
+                    r16 = r7 + r0;
+                    addr=r16+-1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r6 = tmp;
+                    r7 = r16 + -1;
+                    if(r6 != r21) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b8dc;
+                        continue;
+                    }
+                case 0x6b92c:
+                    r15 = r7 + r14;
+                    r2 = ((r15 & 0xffffffffL) < (r23 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b8dc;
+                        continue;
+                    }
+                    r4 = r15 + r0;
+                    r5 = r17 + r0;
+                    r6 = r18 + r0;
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r3;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r7;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r8;
+                    writePages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff] = r11;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r12;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r14;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r15;
+                    /* Next insn is delay slot */ 
+                    r31=0x6b96c;
+                    pc=0x43000;
+                    run_43000(); return;
+                case 0x6b96c:
+                    r3 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    r7 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r8 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r11 = readPages[(r29+28)>>>12][((r29+28)>>>2)&0x3ff];
+                    r12 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r14 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r15 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b8dc;
+                        continue;
+                    }
+                    r7 = r15 + r0;
+                    r6 = ((r23 & 0xffffffffL) < (r7 & 0xffffffffL)) ? 1 : 0;
+                    if(r6 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b918;
+                        continue;
+                    }
+                case 0x6b9a0:
+                    r2 = r11 + 4;
+                    r2 = r2 - r19;
+                    r2 = r2 >> 2;
+                    writePages[(r11+0)>>>12][((r11+0)>>>2)&0x3ff] = r8;
+                    r4 = r8 + r0;
+                    writePages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff] = r2;
+                    r16 = r2 << 5;
+                    /* Next insn is delay slot */ 
+                    r31=0x6b9c4;
+                    pc=0x5c000;
+                    run_5c000(); return;
+                case 0x6b9c4:
+                    r3 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r2 = r16 - r2;
+                    r16 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r3 = r16 < r2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd8c;
+                        run_6bc00(); return;
+                    }
+                    r3 = r2 < r16 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6be00;
+                        run_6be00(); return;
+                    }
+                    r17 = r0 + r0;
+                case 0x6b9f0:
+                    r4 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r3 = readPages[(r4+8)>>>12][((r4+8)>>>2)&0x3ff];
+                case 0x6ba00:
+                    pc=0x6ba00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6ba00() throws ExecutionException { /* 0x6ba00 - 0x6bc00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6ba00:
+                    r3 = r3 < r30 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bcd4;
+                        run_6bc00(); return;
+                    }
+                    r3 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r3 = r30 < r2 ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd28;
+                        run_6bc00(); return;
+                    }
+                    r30 = r2 - r30;
+                    r3 = r30 < r16 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bb40;
+                        continue;
+                    }
+                    r4 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r3 = readPages[(r4+12)>>>12][((r4+12)>>>2)&0x3ff];
+                    r4 = r0 + 2;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bf1c;
+                        run_6be00(); return;
+                    }
+                    r4 = r0 + 3;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6becc;
+                        run_6be00(); return;
+                    }
+                    r4 = r0 + 1;
+                    if(r3 == r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bf34;
+                        run_6be00(); return;
+                    }
+                case 0x6ba68:
+                    r4 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6ba78;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x6ba78:
+                    r2 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 80;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b774;
+                    run_6b600(); return;
+                case 0x6ba90:
+                    writePages[(r11+0)>>>12][((r11+0)>>>2)&0x3ff] = r8;
+                    r3 = r0 + 4;
+                    r11 = r11 + 4;
+                    r8 = r0 + r0;
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b8ec;
+                    run_6b800(); return;
+                case 0x6baac:
+                    r4 = r23 + r0;
+                    r5 = r17 + r0;
+                    r6 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bac0;
+                    pc=0x43000;
+                    run_43000(); return;
+                case 0x6bac0:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd10;
+                        run_6bc00(); return;
+                    }
+                    r16 = r23 + r18;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r3 = r2 + r20;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6be3c;
+                        run_6be00(); return;
+                    }
+                    r4 = r0 + 48;
+                    r23 = r16 + r0;
+                    if(r2 != r4) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bb1c;
+                        continue;
+                    }
+                    r3 = r0 + 48;
+                case 0x6bafc:
+                    r23 = r23 + 1;
+                    addr=r23+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bafc;
+                        continue;
+                    }
+                    r2 = r20 + r2;
+                    addr=r2+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                case 0x6bb1c:
+                    r7 = (r3&0xffffffffL) < (1&0xffffffffL) ? 1 : 0;
+                    r30 = r16 + r0;
+                    r22 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b6dc;
+                    run_6b600(); return;
+                case 0x6bb30:
+                    /* Next insn is delay slot */ 
+                    r31=0x6bb38;
+                    pc=0x6b400;
+                    run_6b400(); return;
+                case 0x6bb38:
+                    /* Next insn is delay slot */ 
+                    pc=0x6b67c;
+                    run_6b600(); return;
+                case 0x6bb40:
+                    r18 = r30 + -1;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bec0;
+                        run_6be00(); return;
+                    }
+                    if(r18 <= 0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bb68;
+                        continue;
+                    }
+                    r4 = r22 + r0;
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bb64;
+                    pc=0x5de00;
+                    run_5de00(); return;
+                case 0x6bb64:
+                    r17 = r2 + r0;
+                case 0x6bb68:
+                    r2 = r18 >> 5;
+                    r2 = r2 << 2;
+                    r2 = r19 + r2;
+                    r3 = r0 + 1;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r18 = r3 << (r18&0x1f);
+                    r2 = r18 & r2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bb90;
+                        continue;
+                    }
+                    r17 = r17 | 2;
+                case 0x6bb90:
+                    r5 = r30 + r0;
+                    r4 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bba0;
+                    pc=0x6b200;
+                    run_6b200(); return;
+                case 0x6bba0:
+                    r3 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r16 = r16 - r30;
+                    r30 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    r18 = r0 + 2;
+                case 0x6bbb0:
+                    if(r17 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd58;
+                        run_6bc00(); return;
+                    }
+                    r3 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r2 = readPages[(r3+12)>>>12][((r3+12)>>>2)&0x3ff];
+                    r3 = r0 + 2;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd34;
+                        run_6bc00(); return;
+                    }
+                    r3 = r0 + 3;
+                    if(r2 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd44;
+                        run_6bc00(); return;
+                    }
+                    r3 = r0 + 1;
+                    if(r2 != r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd54;
+                        run_6bc00(); return;
+                    }
+                    r2 = r17 & 2;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd54;
+                        run_6bc00(); return;
+                    }
+                    r2 = readPages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff];
+                    r2 = r17 | r2;
+                case 0x6bc00:
+                    pc=0x6bc00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6bc00() throws ExecutionException { /* 0x6bc00 - 0x6be00 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6bc00:
+                    r2 = r2 & 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bd54;
+                        continue;
+                    }
+                case 0x6bc0c:
+                    r17 = readPages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff];
+                    r3 = r19 + r0;
+                    r23 = r17 << 2;
+                    r5 = r19 + r23;
+                    r2 = r0 + -1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bc3c;
+                    continue;
+                case 0x6bc28:
+                    r3 = r3 + 4;
+                    r4 = ((r3 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    writePages[(r3+-4)>>>12][((r3+-4)>>>2)&0x3ff] = r0;
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bf74;
+                        run_6be00(); return;
+                    }
+                case 0x6bc3c:
+                    r4 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    if(r4 == r2) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bc28;
+                        continue;
+                    }
+                    r4 = r4 + 1;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r4;
+                    r2 = r19 + r0;
+                case 0x6bc58:
+                    r3 = r0 + 2;
+                    if(r18 == r3) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bfb4;
+                        run_6be00(); return;
+                    }
+                    r3 = readPages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff];
+                    r17 = r17 < r3 ? 1 : 0;
+                    if(r17 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bca8;
+                        continue;
+                    }
+                    r16 = r16 & 31;
+                    if(r16 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bf04;
+                        run_6be00(); return;
+                    }
+                    r2 = r2 + r23;
+                    r4 = readPages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    r31=0x6bc94;
+                    pc=0x5c000;
+                    run_5c000(); return;
+                case 0x6bc94:
+                    r3 = r0 + 32;
+                    r16 = r3 - r16;
+                    r2 = r2 < r16 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bf04;
+                        run_6be00(); return;
+                    }
+                case 0x6bca8:
+                    r4 = r22 + r0;
+                    r5 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bcb8;
+                    pc=0x6b200;
+                    run_6b200(); return;
+                case 0x6bcb8:
+                    r3 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r30 = r30 + 1;
+                    r2 = readPages[(r3+8)>>>12][((r3+8)>>>2)&0x3ff];
+                    r2 = r2 < r30 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bf04;
+                        run_6be00(); return;
+                    }
+                case 0x6bcd4:
+                    r4 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bce4;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x6bce4:
+                    r2 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r0;
+                    r2 = r0 + 163;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b774;
+                    run_6b600(); return;
+                case 0x6bcfc:
+                    r6 = r0 + 1;
+                case 0x6bd00:
+                    r4 = r16 + 2;
+                    addr=r16+2;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b7e4;
+                    run_6b600(); return;
+                case 0x6bd10:
+                    addr=r23+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r16 = r23 + r0;
+                    r30 = r0 + r0;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b740;
+                    run_6b600(); return;
+                case 0x6bd28:
+                    r18 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bbb0;
+                    run_6ba00(); return;
+                case 0x6bd34:
+                    r4 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    r4 = r2 - r4;
+                    writePages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff] = r4;
+                case 0x6bd44:
+                    r2 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bc0c;
+                        continue;
+                    }
+                case 0x6bd54:
+                    r18 = r18 | 16;
+                case 0x6bd58:
+                    r4 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    r3 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r22;
+                    r2 = r18 + r0;
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r30;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b774;
+                    run_6b600(); return;
+                case 0x6bd74:
+                    r2 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b774;
+                    run_6b600(); return;
+                case 0x6bd80:
+                    r6 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bd00;
+                    continue;
+                case 0x6bd8c:
+                    r18 = r2 - r16;
+                    r4 = r22 + r0;
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bda0;
+                    pc=0x5de00;
+                    run_5de00(); return;
+                case 0x6bda0:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6be4c;
+                        run_6be00(); return;
+                    }
+                    r2 = r18 + -1;
+                    r3 = r2 >> 5;
+                    r3 = r3 << 2;
+                    r3 = r19 + r3;
+                    r4 = r0 + 1;
+                    r3 = readPages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff];
+                    r4 = r4 << (r2&0x1f);
+                    r3 = r4 & r3;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6beb4;
+                        run_6be00(); return;
+                    }
+                    r2 = r2 < 2 ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bf10;
+                        run_6be00(); return;
+                    }
+                    r4 = r22 + r0;
+                    r5 = r18 + -2;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bdec;
+                    pc=0x5de00;
+                    run_5de00(); return;
+                case 0x6bdec:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bf10;
+                        run_6be00(); return;
+                    }
+                    r17 = r0 + 3;
+                    /* Next insn is delay slot */ 
+                    pc=0x6be50;
+                    run_6be00(); return;
+                case 0x6be00:
+                    pc=0x6be00;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6be00() throws ExecutionException { /* 0x6be00 - 0x6c000 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6be00:
+                    r17 = r16 - r2;
+                    r4 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    r6 = r17 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6be18;
+                    pc=0x5cc00;
+                    run_5cc00(); return;
+                case 0x6be18:
+                    r30 = r30 - r17;
+                    r22 = r2 + r0;
+                    r19 = r2 + 20;
+                    r17 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b9f0;
+                    run_6b800(); return;
+                case 0x6be30:
+                    r22 = r0 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b6b4;
+                    run_6b600(); return;
+                case 0x6be3c:
+                    r30 = r0 + r0;
+                    r7 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b740;
+                    run_6b600(); return;
+                case 0x6be4c:
+                    r17 = r0 + r0;
+                case 0x6be50:
+                    r4 = r22 + r0;
+                    r5 = r18 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6be60;
+                    pc=0x6b200;
+                    run_6b200(); return;
+                case 0x6be60:
+                    r30 = r30 + r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b9f0;
+                    run_6b800(); return;
+                case 0x6be6c:
+                    r30 = r16 + r18;
+                    addr=r30+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r16 = r30 + r0;
+                    r3 = r20 + r2;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6b738;
+                        run_6b600(); return;
+                    }
+                case 0x6be8c:
+                    r16 = r16 + 1;
+                    addr=r16+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r3 = r20 + r2;
+                    addr=r3+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r3 = tmp;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6be8c;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6b738;
+                    run_6b600(); return;
+                case 0x6beb4:
+                    r17 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6be50;
+                    continue;
+                case 0x6bec0:
+                    r17 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bb68;
+                    run_6ba00(); return;
+                case 0x6becc:
+                    r3 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6ba68;
+                        run_6ba00(); return;
+                    }
+                case 0x6bedc:
+                    r3 = readPages[(r29+100)>>>12][((r29+100)>>>2)&0x3ff];
+                    r4 = readPages[(r29+104)>>>12][((r29+104)>>>2)&0x3ff];
+                    writePages[(r3+0)>>>12][((r3+0)>>>2)&0x3ff] = r2;
+                    r2 = r0 + 1;
+                    writePages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff] = r2;
+                    writePages[(r19+0)>>>12][((r19+0)>>>2)&0x3ff] = r2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r22;
+                    r2 = r0 + 98;
+                    /* Next insn is delay slot */ 
+                    pc=0x6b774;
+                    run_6b600(); return;
+                case 0x6bf04:
+                    r18 = r0 + 33;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bd58;
+                    run_6bc00(); return;
+                case 0x6bf10:
+                    r17 = r0 + 2;
+                    /* Next insn is delay slot */ 
+                    pc=0x6be50;
+                    continue;
+                case 0x6bf1c:
+                    r4 = readPages[(r29+108)>>>12][((r29+108)>>>2)&0x3ff];
+                    if(r4 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bedc;
+                        continue;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6ba68;
+                    run_6ba00(); return;
+                case 0x6bf34:
+                    if(r30 != r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6ba68;
+                        run_6ba00(); return;
+                    }
+                    r3 = r16 < 2 ? 1 : 0;
+                    if(r3 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bedc;
+                        continue;
+                    }
+                    r4 = r22 + r0;
+                    r5 = r16 + -1;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bf58;
+                    pc=0x5de00;
+                    run_5de00(); return;
+                case 0x6bf58:
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6ba68;
+                        run_6ba00(); return;
+                    }
+                    r3 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r2 = readPages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x6bedc;
+                    continue;
+                case 0x6bf74:
+                    r2 = readPages[(r22+8)>>>12][((r22+8)>>>2)&0x3ff];
+                    r2 = r17 < r2 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6bfdc;
+                        continue;
+                    }
+                    r2 = r19 + r0;
+                    r3 = r17 + r0;
+                case 0x6bf90:
+                    r4 = r3 + 1;
+                    r3 = r3 + 4;
+                    r3 = r3 << 2;
+                    writePages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff] = r4;
+                    r3 = r22 + r3;
+                    r4 = r0 + 1;
+                    writePages[(r3+4)>>>12][((r3+4)>>>2)&0x3ff] = r4;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bc58;
+                    run_6bc00(); return;
+                case 0x6bfb4:
+                    r4 = readPages[(r29+96)>>>12][((r29+96)>>>2)&0x3ff];
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    r3 = r3 + -1;
+                    if(r3 == r16) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c034;
+                        run_6c000(); return;
+                    }
+                    r18 = r0 + 34;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bd58;
+                    run_6bc00(); return;
+                case 0x6bfdc:
+                    r5 = readPages[(r22+4)>>>12][((r22+4)>>>2)&0x3ff];
+                    r4 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r5 = r5 + 1;
+                    /* Next insn is delay slot */ 
+                    r31=0x6bff0;
+                    pc=0x5b800;
+                    run_5b800(); return;
+                case 0x6bff0:
+                    r6 = readPages[(r22+16)>>>12][((r22+16)>>>2)&0x3ff];
+                    r5 = r22 + 12;
+                    r6 = r6 + 2;
+                    r4 = r2 + 12;
+                case 0x6c000:
+                    pc=0x6c000;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6c000() throws ExecutionException { /* 0x6c000 - 0x6c200 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6c000:
+                    r6 = r6 << 2;
+                    r19 = r2 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6c010;
+                    pc=0x48fdc;
+                    run_48e00(); return;
+                case 0x6c010:
+                    r4 = readPages[(r29+88)>>>12][((r29+88)>>>2)&0x3ff];
+                    r5 = r22 + r0;
+                    /* Next insn is delay slot */ 
+                    r31=0x6c020;
+                    pc=0x5ba00;
+                    run_5ba00(); return;
+                case 0x6c020:
+                    r22 = r19 + r0;
+                    r3 = readPages[(r19+16)>>>12][((r19+16)>>>2)&0x3ff];
+                    r2 = r19 + 20;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bf90;
+                    run_6be00(); return;
+                case 0x6c034:
+                    r3 = r16 >> 5;
+                    r3 = r3 << 2;
+                    r2 = r2 + r3;
+                    r2 = readPages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff];
+                    r3 = r0 + 1;
+                    r16 = r3 << (r16&0x1f);
+                    r18 = r16 & r2;
+                    r18 = ((r0 & 0xffffffffL) < (r18 & 0xffffffffL)) ? 1 : 0;
+                    r2 = r0 + 34;
+                    r18 = r2 - r18;
+                    /* Next insn is delay slot */ 
+                    pc=0x6bd58;
+                    run_6bc00(); return;
+                case 0x6c200:
+                    pc=0x6c200;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6c200() throws ExecutionException { /* 0x6c200 - 0x6c400 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6c200:
+                    r29 = r29 + -48;
+                    writePages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff] = r16;
+                    r16 = 7 << 16;
+                    r16 = r16 + 30712;
+                    addr=r16+48;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    writePages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff] = r31;
+                    writePages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff] = r18;
+                    writePages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff] = r17;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c4d8;
+                        run_6c400(); return;
+                    }
+                case 0x6c228:
+                    r24 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r15 = r24 >> 5;
+                    r15 = r15 << 2;
+                    r24 = r24 & 31;
+                    r15 = r6 + r15;
+                    if(r24 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c24c;
+                        continue;
+                    }
+                    r15 = r15 + 4;
+                case 0x6c24c:
+                    r3 = readPages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff];
+                    writePages[(r15+-4)>>>12][((r15+-4)>>>2)&0x3ff] = r0;
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r10 = r15 + -4;
+                    r12 = r10 + r0;
+                    r5 = r10 + r0;
+                    r8 = r0 + r0;
+                    r14 = r0 + r0;
+                    r11 = r0 + r0;
+                    r17 = r0 + 8;
+                    r25 = r0 + 32;
+                    r9 = r3 + 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c334;
+                        continue;
+                    }
+                case 0x6c284:
+                    r7 = r16 + r2;
+                    addr=r7+0;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r7 = tmp;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c430;
+                        run_6c400(); return;
+                    }
+                    r7 = (r2&0xffffffffL) < (33&0xffffffffL) ? 1 : 0;
+                    if(r7 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c4ac;
+                        run_6c400(); return;
+                    }
+                    r2 = r14 < r11 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c320;
+                        continue;
+                    }
+                    r2 = ((r5 & 0xffffffffL) < (r12 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c310;
+                        continue;
+                    }
+                    r2 = r8 < 8 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c310;
+                        continue;
+                    }
+                    r8 = r17 - r8;
+                    r8 = r8 << 2;
+                    r18 = r25 - r8;
+                    r7 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r2 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6c2e8;
+                    continue;
+                case 0x6c2e4:
+                    r7 = r3 + r0;
+                case 0x6c2e8:
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 + 4;
+                    r13 = r3 << (r18&0x1f);
+                    r7 = r7 | r13;
+                    r3 = r3 >>> (r8&0x1f);
+                    writePages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff] = r7;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r7 = ((r2 & 0xffffffffL) < (r12 & 0xffffffffL)) ? 1 : 0;
+                    if(r7 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c2e4;
+                        continue;
+                    }
+                case 0x6c310:
+                    r2 = ((r6 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c48c;
+                        run_6c400(); return;
+                    }
+                    r8 = r0 + 8;
+                case 0x6c320:
+                    r3 = r9 + r0;
+                case 0x6c324:
+                    addr=r3+1;
+                    tmp = readPages[(addr)>>>12][((addr)>>>2)&0x3ff];
+                    tmp = (tmp>>>(((~addr)&3)<<3)) & 0xff;
+                    r2 = tmp;
+                    r9 = r3 + 1;
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c284;
+                        continue;
+                    }
+                case 0x6c334:
+                    if(r11 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c4b8;
+                        run_6c400(); return;
+                    }
+                case 0x6c33c:
+                    r2 = ((r5 & 0xffffffffL) < (r12 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c3a4;
+                        continue;
+                    }
+                    r2 = r8 < 8 ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c3a4;
+                        continue;
+                    }
+                    r2 = r0 + 8;
+                    r8 = r2 - r8;
+                    r8 = r8 << 2;
+                    r9 = r0 + 32;
+                    r9 = r9 - r8;
+                    r7 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r2 = r5 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6c37c;
+                    continue;
+                case 0x6c378:
+                    r7 = r3 + r0;
+                case 0x6c37c:
+                    r3 = readPages[(r2+4)>>>12][((r2+4)>>>2)&0x3ff];
+                    r2 = r2 + 4;
+                    r4 = r3 << (r9&0x1f);
+                    r4 = r7 | r4;
+                    r3 = r3 >>> (r8&0x1f);
+                    writePages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff] = r4;
+                    writePages[(r2+0)>>>12][((r2+0)>>>2)&0x3ff] = r3;
+                    r4 = ((r2 & 0xffffffffL) < (r12 & 0xffffffffL)) ? 1 : 0;
+                    if(r4 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c378;
+                        continue;
+                    }
+                case 0x6c3a4:
+                    r2 = ((r6 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c500;
+                        run_6c400(); return;
+                    }
+                    r2 = r6 + r0;
+                case 0x6c3b4:
+                    r5 = r5 + 4;
+                    r3 = readPages[(r5+-4)>>>12][((r5+-4)>>>2)&0x3ff];
+                    r2 = r2 + 4;
+                    writePages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff] = r3;
+                    r3 = ((r10 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c3b4;
+                        continue;
+                    }
+                case 0x6c3d0:
+                    r2 = r2 + 4;
+                    r3 = ((r10 & 0xffffffffL) < (r2 & 0xffffffffL)) ? 1 : 0;
+                    writePages[(r2+-4)>>>12][((r2+-4)>>>2)&0x3ff] = r0;
+                    if(r3 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c3d0;
+                        continue;
+                    }
+                case 0x6c3e4:
+                    r2 = readPages[(r15+-4)>>>12][((r15+-4)>>>2)&0x3ff];
+                case 0x6c3ec:
+                    if(r2 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c410;
+                        run_6c400(); return;
+                    }
+                case 0x6c3f4:
+                    if(r6 == r10) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c528;
+                        run_6c400(); return;
+                    }
+                    r10 = r10 + -4;
+                case 0x6c400:
+                    pc=0x6c400;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+    private final void run_6c400() throws ExecutionException { /* 0x6c400 - 0x6c600 */
+        int addr, tmp;
+        for(;;) {
+            switch(pc) {
+                case 0x6c400:
+                    r2 = readPages[(r10+0)>>>12][((r10+0)>>>2)&0x3ff];
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c3f4;
+                        run_6c200(); return;
+                    }
+                case 0x6c410:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r18 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r17 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + 5;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6c430:
+                    r8 = r8 + 1;
+                    r2 = r8 < 9 ? 1 : 0;
+                    r11 = r11 + 1;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c468;
+                        continue;
+                    }
+                    r2 = readPages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff];
+                    r2 = r2 << 4;
+                case 0x6c450:
+                    r7 = r7 & 15;
+                    r7 = r2 | r7;
+                    writePages[(r5+0)>>>12][((r5+0)>>>2)&0x3ff] = r7;
+                    r3 = r9 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6c324;
+                    run_6c200(); return;
+                case 0x6c468:
+                    r2 = ((r6 & 0xffffffffL) < (r5 & 0xffffffffL)) ? 1 : 0;
+                    if(r2 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c320;
+                        run_6c200(); return;
+                    }
+                    writePages[(r5+-4)>>>12][((r5+-4)>>>2)&0x3ff] = r0;
+                    r2 = r0 + r0;
+                    r5 = r5 + -4;
+                    r8 = r0 + 1;
+                    /* Next insn is delay slot */ 
+                    pc=0x6c450;
+                    continue;
+                case 0x6c48c:
+                    r12 = r5 + -4;
+                    writePages[(r5+-4)>>>12][((r5+-4)>>>2)&0x3ff] = r0;
+                    r14 = r11 + r0;
+                    r5 = r12 + r0;
+                    r8 = r0 + r0;
+                    r3 = r9 + r0;
+                    /* Next insn is delay slot */ 
+                    pc=0x6c324;
+                    run_6c200(); return;
+                case 0x6c4ac:
+                    r7 = r0 + 41;
+                    if(r2 == r7) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c550;
+                        continue;
+                    }
+                case 0x6c4b8:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r18 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r17 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + 4;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6c4d8:
+                    writePages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff] = r4;
+                    writePages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff] = r5;
+                    writePages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff] = r6;
+                    /* Next insn is delay slot */ 
+                    r31=0x6c4ec;
+                    pc=0x6b400;
+                    run_6b400(); return;
+                case 0x6c4ec:
+                    r6 = readPages[(r29+24)>>>12][((r29+24)>>>2)&0x3ff];
+                    r5 = readPages[(r29+20)>>>12][((r29+20)>>>2)&0x3ff];
+                    r4 = readPages[(r29+16)>>>12][((r29+16)>>>2)&0x3ff];
+                    /* Next insn is delay slot */ 
+                    pc=0x6c228;
+                    run_6c200(); return;
+                case 0x6c500:
+                    if(r24 == r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c3e4;
+                        run_6c200(); return;
+                    }
+                    r2 = readPages[(r15+-4)>>>12][((r15+-4)>>>2)&0x3ff];
+                    r24 = r0 - r24;
+                    r3 = r0 + -1;
+                    r3 = r3 >>> (r24&0x1f);
+                    r2 = r3 & r2;
+                    writePages[(r15+-4)>>>12][((r15+-4)>>>2)&0x3ff] = r2;
+                    /* Next insn is delay slot */ 
+                    pc=0x6c3ec;
+                    run_6c200(); return;
+                case 0x6c528:
+                    r31 = readPages[(r29+44)>>>12][((r29+44)>>>2)&0x3ff];
+                    r2 = r0 + 1;
+                    writePages[(r10+0)>>>12][((r10+0)>>>2)&0x3ff] = r2;
+                    r18 = readPages[(r29+40)>>>12][((r29+40)>>>2)&0x3ff];
+                    r17 = readPages[(r29+36)>>>12][((r29+36)>>>2)&0x3ff];
+                    r16 = readPages[(r29+32)>>>12][((r29+32)>>>2)&0x3ff];
+                    r2 = r0 + 5;
+                    r29 = r29 + 48;
+                    /* Next insn is delay slot */ 
+                    pc=r31;
+                    return;
+                case 0x6c550:
+                    r3 = r3 + 2;
+                    writePages[(r4+0)>>>12][((r4+0)>>>2)&0x3ff] = r3;
+                    if(r11 != r0) {
+                        /* Next insn is delay slot */ 
+                        pc=0x6c33c;
+                        run_6c200(); return;
+                    }
+                    /* Next insn is delay slot */ 
+                    pc=0x6c4b8;
+                    continue;
+                case 0x6c5fc:
+                case 0x6c600:
+                    pc=0x6c600;
+                    return;
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(pc&0xffffffffL,16));
+            }
+            /* NOT REACHED */
+        }
+    }
+
+    private static final int[] _data1 = decodeData("\177\177\177\177x\000\000\000\000\000 \020\010\004\002\001",0x2);
+    private static final int[] _data2 = decodeData("\177\177\177\177x\000\000\000\000\000 \020\010\004\002\001",0x2);
+    private static final int[] _data3 = decodeData("\022\\h6{UXd\020\033Mw!\001`a9\034lR\001\034Js\023KA \000\000\000\000\022\\jVs-\\o;[D\006{Uhp:]\004\0063=dm0]\004\002CUfe\020\011l6\0234N,\020\011n\006c\005Rn\023H\rw\021\000Na8\034\rF)\034R.\005\000\000\000\002\005\006M\"H\005R\003QPe\020\020(4j\024@C9\033n7\033\005fs2[,&c\025d 3\033n\"\0025jl:\032.\006c\024@E7\035M\027\023=\\m2[NG\030(@ ![n\007KIRg4\035\004\002B\014R \030N'\023A4d0\030M$\004k\005dc7H\010&\013eJ\000\000\000\nFC%f 4\\d\004\n\r\032E\026\010\016&+1Ja9Y$\003\0018r5\027\rD\002A\011\014e7\030m\007+IFh\021\n%B\001H` %\035-b\001H`1\032BD\002\002AXa:\031Mw\0234@i7\031\014W\003\025\\d2[NB\003YJr9Z-vq8\000A!S(R\003\r^m2\\d\007;%hh\020\020(%\032=\030U*\021)EI\001\034O\020\025h\025\022I\002N*\026'2\003\031^r\020\031\014W#\005Rl9H\016&+\005H :\032\014R\003!Jl8\010\014fK1J.\005\010\004\005#!Rs\020\032.2\003\031de2H\0166{\031hw0\\LRa\001Bn2\010\017\026{T@a9\031$\007;\025Xc7[,R\003Q^ 9\031,FKMhr4XNW#\024@i:\010\016Vs\021Jr\005\010\004\006\033\025dt0Z-b\003\r^n2\032.FK=\\s\035H\014\027\031\001^u:\033\r\026s\025H 4[D\007#!J #SJR\002\035Jn2\\L\026a\001 u1\033\r\026\031\001\030i1Y-g\033\024\\\n\"\031,FK\rBt2Y\004\007#<@t4\031$\007;%fe9]\004\006\023\025Rn3H\011\022\003\025le9\010\r\006\013\020@t4\031$\007\0031Ja9].&)\001^f\020\034LV\013\021Rn3BD\002\003\011^o5\\d\006{\030@(1].'\023\025\\t6\036$\007\033AJn2\032-f9\001fo6Y$\007#%Ze\020\031\014V\013\020@f7\\D\007#\005p 9\031,\027\033=\\s\024KA%#!J 7\031.v+Mh ;\031.'\033%^n\020\030l\026q\001De\020\031Mw+9H 0]\004\007#!J  PiT)\001Po6Y.\006\013\035J:\005\010\004\006CQhp\035\013ew\033=jr1Y,f{INe\027\033LW!=`/0XmV)5Fr7\\n6\013Mf/\005\002JW\033\005Ne\035\002L\026\0335J -Sj\005\"%\036N\027\013Eei\0016F$S\010Ui8\\.\005\002Iw\003QRo7\034g Q\000@-4\013\004\002i5Pe6\034\004\002\001\000@ \020\010\004\002\001\000@ \020\034m\006{\\@t4\032.2\003!Jl8\010\014\026s\020@e<\032.@Q\000@-3\013\004\002i5Lo9\033,\027!\001\014O)\023(\025!\000@ \020\034lW!\001^u:\034\016W!\001Li6\031$\0063=dm0]\001\"\001\000Zo\026\010\005Rk=jt3\032-F)\001\014I&\021$\002\001\000@ 9Y.B\003=jt8\035.B\003\031Rl2H\rf\0135J\n\020\010\005W\0210@-\026\\LW\003=dt\020\021I\024b\024@ \020\010\004\002\003MJt\020\034LW\003=dt\020\031M\026c\024@n0[,PQ\000@-6\013\004\002i5fy6XMvc1Rs:\010\010dJ1\n \020\034lW!\001fy6XMva\001Xi9]\004\0063%Xe\020\033L\026k\024\024 \020\010\004\002\001\000Z-6\030,&+1Hu6\\\004\002\001\000@ \020\010\004\002C=Xd\020\033L\026k\024@f7\\D\002i5fy6XMvc1Rs:\n!\"\001\000@ \020\010\005RkYRc2[\014\026\023\025Xs\020\021I\024b\024@ 9Y.B\003\031Rl2H\rf\0135J 3\033n\"\0031Bb2[\004\006#UZp\020\032-b\002Y\022C\"H\014f{IZa:\002D\002\001\000@ \020\013%W\033\025hp1H\011e*5\004E)\010\004\002\001\000@s2]\004\007\003I^g9\030-R\003\r^u7\035\014W\020(@ \020\010\004\002\0014Zc8\035$\004\032A* \020\010\004\002\001\000@ \020\010\0166+P@t0\\Lv+P@p9\033l6+Mfo9\002D\002\001\000@ \020\013%VK9Rt6Y-R\0029*M!\021*\"\001\000@d2YM\026s\024@'2[.\007#dN 6Y-V{Ir\n\020\010\004\002\001\000@-\026[,\027C\025dr7\\N2\0029*M!\021*\"\003MJt\020\033NVk\011Jr\020\033lb\003\025dr7\\N2\003\011Jf7\\LR\003\025pi:\032-f8(@ \020\010\004\002\0014Zm0^\014F+Ahh\020\023JTj\011\nR\020\010\0166+P@r2XnW\023MRo7\010\014F+Ahh\020\031Mw\021\001Za1\\Mr\003\rBl6\034d\006\0139H \020\\n&\030(@ \026]HDJ\035\022T\020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010\0166+P@v2\\L&{MRt<H\rF+YJl\005\010\004\002j\021&Y&PItau,A&\025(R\001\000@ \020\010\004\002\001\001He3\032-f)\001Nl7XL\026a\001fy6XMv`(@ \026Umfy5Xa1\031-Bk%\\d2[NB\001\000@ \020\010\0167+A`r2\\n2\003]Br7\032-f;L@a1\033nW!\001Rn2\031-g#\025H 6\030,&+1f\n\020\010\005U;9^-7[\014Bk\031^r\020\010\004\002\001\000@ \020\010\004\002\003Mjp8\034LW\033L@w0\\MfK9Ns\020\030,&{Uh 7[\014B\001\010Bf7\\D\"\003Mrn:\030/\000Q\000@-+]\017\027\003\024Zm4\\mV\013QFh\020\010\004\002\001\000@ \020\031-f\013\011Xe\020\035\017\027\003\024@c4\031,6[%\\g\020\n\016v\013I\\ 0XMw+P@t<\\\014R\0035Rs6X.F\033 R\n\020\010\004\002\001\000@-\026].6)5ft2\033nW!\000@ \020\010\004\002\003\031Rx\020\031Mw\021\000NR2[\014\027+9Fh\033\r\004r\002%\010E\020\n\0166+\024@d7Xn2H(@ \020\010\004\002\0014Zm9]L2\001\000@ \020\010\004\002\001\000@ \020\010\0166+P@o:]\016\007+P@e9\034Mw\021\001Ze9\\l\026;\024@f7\\MV\013P@t7H\016FC\005h 7YD\004jL@V4\\nV\0130@S:\035,FK<\024 \020\013*ba\000Z-;\031.'\033%^n\020\010\004\002\001\000@ \020\010\004\007\033!^w\020\035LW\023MRo7\010\014\026s\020@e<\032.@P\000\000\0007].G\003Uh 3\033n&k\005h\000\000\000\rfy5Xa1\031-Bk%\\d2[N@\0039^-7[\014Bk\031^r\000\000\016GKAJ-6Z.6k\005hc4\000\000\000\001\025fU7\032mf{]\\ ;X.&s%\\g\020\033\014W3\025X.\005\000\000\000\003!Jl8\000\000\000\000\001Lo9\033,\027 \000\000o:]\014fK1J\0006\030,&+1Hu6\\\000\000\000\001fy6XMvc1Rs:\000\000\0073%Fe6\030,&+1f\000\000\034LW\003=dt\000\000\0166+Q`c\000\000\000\007\003I^g9\030-R\003\r^u7\035\014W\020\000Js(\034Mv;IBm\020\030mw+9he9\010\rw+P@o3\010\016&\0139Ne\020\n\006\002iApf3\031LbI8\024\0001\\\016P\002\r U\020\035\017\027\003\024\000\000\000\000\004W\032U\\k7\033nvq\001\006P*H\016GKAJ \024\035.6)\000l5\030\014EB\001Xj1\030\013\004\006\031Xhd:\035F\"a\000l51L\006\"\003=d \033\r'\003\011XR.\005\000\000\006K9Rt6Y-P\003%\\i:\033,Vi\001la6\035,P\000\000\000%9R-fKQZe6H\016f\0131je\020\033nW!\001^f\020\034L\026s\035J \024\014\005S\003aLf\024KA \0035Bx2\\N&{If\000\000\000\rV\013aRm:[$\006+Ido9\010\0146{U\\t\000\033,\027C\021Jp:\032\000\000\000\000\000r2XnW\023MRo7\010\014F+Ahh\000\035.6)5ft2\033nW \000\000m9]L0\000\000\000\000;\031.'\033%^n\000\021.'\023=d:\020\020l\026s9^t\020\033n\006+8@s<[,&{0@l4\\nB\003\031Rl2H\004\"+LD.\005\000\000\004+Ido9\016D\004\033\005\\n7]\004\006{AJn\020\025I\024\032\024@l0XLVa\001Hu6\\\004\0063%Xe\020\010DW\031\010\\\n\000\000\010W\023I^r\035\010\0106\0139\\o:\010\rw\003\025\\ :\033n\006c\025le6\010\014fK1J \021\011.2\0218\024\000'\033d\007#=` 6\031.f+0@s7].&\033\025f 3Z.f+8\000\000#\032.'\033P@p0\\n2p\001\014u9\035\r\006+H@p0\\n2p\000\000\000\"^\016G\023\004@p0\\n2\003Q^ 3Y-f+IBt2H\rFKMhi7\031d\007\023\025`o9\035\005`\000\001\nr9\033n#Q\001\006a7\033Mw!\001^p2[D\007\023\025`o9\035\004\0063%Xe\020\010DW\031\010\\\n\000\000\000\004+ahr0H\016\006\013Mf 7\031,V#\025H :\033d\0063%\\d\020\031.'\023=d.\000\000\000\000\0029^ 7].G\003Uh 3\032-F)\001fp2Xm\0263%Jd\020\n\016W\033\024@t4\031$\002\0215^\"\020\033n\007#%^n\020\033n\"\003QPe\020\010D\027#<D 8\034lW+\021^ 7\\\0146{\021J)\027\002@\004+Ido9\016D\004\033\005\\n7]\004\006{AJn\020\033nW#Ajt\020\031M\026c\024@\"\022\\d\"p(\000\000\000\000\000\020l \000\001\006D\000\000\0104 \000\000C\"\000\000\004\032\020\000\000!Q\000\000\002\r\010\000\000\020h@\000\001\006D\000\000\0104 \000\000C\"\000\000\004\032\020\000\000!Q\000\000\002\r\010\000\000\020h@\000\001\006D\000\000\0104 \000\000C\"\000\000\004\033p\000\000!f@\000\002\r\010\000\000\020h@\000\001\006D\000\000\0104 \000\000C\"\000\000\004\032\020\000\000!Q\000\000\002\r\010\000\000\020h@\000\001\006D\000\000\0104 \000\000C\"\000\000\004\032\020\000\000!Q\000\000\002\016j\000\000\020h@\000\001\007\003\000\000\0104 \000\000C\"\000\000\004\032\020\000\000!a \000\002\r\010\000\000\020h@\000\001\007\014\000\000\0104 \000\000C\"\000\000\004\034L\000\000!Q\000\000\002\r\010\000\000\020h@\000\001\006N\ndJ\r\n 6\030,&+1f 3\032-F+9Bm2@\000\000\000\001de8\033n'!\001Li6\031-f\0135J\0009^-V\023=X 6\032.7!\001Li6\031-f\0135J\000\000\000\000\006{Uhp:]\004\0063%Xe7\030-V(\001\002r3]-V+9h 7].B\003=L 9\030-f;\024\\\000\000\022-Fc\025Na6\010\0167K5Do6\010\rf\0135J 6\031-f;QP\000\000\025\r\006+IJ'9H\rV{IJ :\032\014\026q\001^n2H\0146C\005da1]\014W\0218\000\000\000\000\005 \000\000\000U7\032mf{]\\ 3\035-f\033QRo7\013@\000\000\001\006-9]\017\026c\024@\"\036O$\"\003\r^m8\030.&KM^n\020\031\014W#\025Ft2Y\005`\000\000\000U7\032mf{]\\ 7\\\014W\023\005ho9\013@\000\000\001&t9\030-f;\025 a9\031-g#!Js4\\`\000\002Q^o\020\033,\026sd@'\024Ie`\000\000\000E<\034\rvs\025\\t\020\032.2\0039Jg0]\r\0273\024\\\000\000\000\0106{9le9\035\014V!\001ho\020\032-g#\025Ne9\010\014f{H@b4[L\027\023d@l7Ym\026\031\001^p2\\L\027#=d.\000\010HTzHD 4\\d\006#\025`r2Xl\027#\025H;\020\035.6)\000DX'TD\"\003%\\s:\031,\026!8\000I6\033\014V;\005XO8\031.&\013Q^r$\030-f#1J\000\000\000\011w\003\025da7\031\n7#\005Fk'\033nD+5`t<@\000\000\000\001\036p2\\L\027#=dS:\030,6Z9^t\"[.\007#d\000\000\000\025L\026cUJ 7\033nB\003\021Jf4[LV!\000P\0000Y\014G\020\000\000\000\000\030,F#IJs9@\r\026sP\000f6\033l\027 \000\000\0006\034m@\003\021Rv\000\033-v \000\000\001!W\000\000\n\006\000\000\000Ou@\000\004~(\000\000(\022 \000\002>L\000\000\023r\000\000\001\036t\000\000\n\011\030\000\000P!@\000\005\003t\000\000'o\000\000\002@&\000\000\023\177\000\000\001 *\000\000\011tP\000\000O\001\000\000\004wT\000\000'\025`\000\0028|\000\000\023S`\000\001\034\177\000\000\011m \000\000Ms@\000\004pp\000\000'\001\000\000\0027\024\000\000\0235P\000\001\033\023\000\000\011WP\000\000M1\000\000\004j$\000\000'W\000\000\002<b\000\000\023b@\000\001 f\000\000\011A8\000\000L\r@\000\004N,\000\000&\003@\000\0020\034\000\000\023\001`\000\001\024{\000\000\011'p\000\000L\007\000\000\004`8\000\000%  \000\002*\010\000\000\022> \000\001\030\016\000\000\011(8\000\000L\007\000\000\004T(\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000JF@\000\004Tl\000\000%)@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011'@\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004`8\000\000&\003@\000\0020\034\000\000\023\001`\000\001\030\016\000\000\011@p\000\000L\007\000\000\004U\014\000\000%F`\000\002.2\000\000\022@\020\000\001\026B\000\000\0116x\000\000K\017\000\000\004\\d\000\000%O`\000\002(@\000\000\022_P\000\001\027<\000\000\011 \010\000\000Kw\000\000\004V<\000\000%\000 \000\002(\002\000\000\022@\020\000\001\024\001\000\000\011 \010\000\000J\000@\000\004P\004\000\000%\000 \000\002(\002\000\000\022@\020\000\001\024\001\000\000\011 \010\000\000J\000@\000\004Ul\000\000%\000 \000\002+\022\000\000\022@\020\000\001\024\001\000\000\011 \010\000\000J\000@\000\004P\004\000\000%\000 \000\002(\002\000\000\022@\020\000\001\024\001\000\000\011 \010\000\000J\000@\000\004P\004\000\000%\000 \000\002(\002\000\000\022@\020\000\001\024\001\000\000\011 \010\000\000J\000@\000\004P\004\000\000%\000 \000\002(\002\000\000\022@\020\000\001\024\001\000\000\011 \010\000\000J\000@\000\004P\004\000\000%\000 \000\002(\002\000\000\022@\020\000\001\024\001\000\000\011 \010\000\000Jf\005#=^ 6X-gI\000N(\023K@\000\000\001\034o\020\035L\026cUJ 3Z.f+8\\\000\"\032.fKMRo7\010\014'I\001te9\033e`\000\000\000%9U-f[9^w7\010\rw\003QRo7\010\005\002i4Js\024KA \000\000\000%9U-f[9^w7\010\0167;%hc4\010\005\002i\025F)\027\002@\000\000\000\000%9S-\027\033MRn3H\004W\0318\024\000\000\011.2+L\\\n\000\000\010W\023I^r\020\032-b\002\r\030I\020\030.&;UZe7\035\0163Q\000\000\000\000\000\0106C=fe7\010\0105\002T@d7Y.2\0039^t\020\034nW\003A^r:\010\rF{9N 9\031,vKMhe9\034e`\001Xj0\031\000\000\000\000\000l5\030L\000\000\000\000\000c\033\r\014G#Xd\000\033\r,3\001H\000\000\000\021.'\023=d:\020\023Mr\0035Jm7\\O\022\003\031^r\020\031\017\026s\005Zi1H\014'+\031Le9\013A \000\000\000C7[Nf+Ifi7[D\007#\005Dl2H\r\026s\r^m8\033\014W#\024\\\000\000\000\000\005+9Vn7]mb\003\025\\c7Y\r\026s\034\\\000\000\000\011\026c1Jg0[\010&c=Fk*\031.&k%\\a:\033n \000\001nh4[\014P\000\000\000u7\035\r\026`\000\000\0002[\0166(\000\000\000\000\024\014\027\023MRn3H\0166{Udc2H\014fK1J \023I.28(\000\000\000\021Mw+9H \023_$r\003%\\s:\031,\026!\001^f\020\031-f!5^f\026YM\026c\024\\\000\000\000\004W\031 Jd\024H\007\"\001\025f \024\011.2\001\025f)\035\010\004W\030(\000\000\000\000\004W\031\000Z #\032-F)\000Js\026\010\rFK9J \022Y\004\002A\025f \022\\e\023Q\000Js\005\000\000\005;\005dn4[Lp\0021Bb2[\004\006s\005Ze\020\034nF\013Ihs\020\035m\027# @a\020\034m\006K\031h-9\\\014\026\033\024@c4\030.&\013\rhe9\013@\005\033\025di7].2\003\025dr7\\@\000\000\001\004u3H\r\026q\001\002C&Q%B\003\r^d2H\014f{1Xo;\\`\000\000\000P0<\011/\003Q$\000\000\000i\031@\000\006N\\\000\0004u`\000\003'.\000\000\032:p\000\001SW\000\000\r\0358\000\000ik@\000\006N\\\000\0004u`\000\003$Z\000\000\032:p\000\001SW\000\000\r\0358\000\000ik@\000\006N\\\000\0004u`\000\003'.\000\000\032:p\000\001SW\000\000\r\0358\000\000ik@\000\006N\\\000\0004u`\000\003'.\000\000\032:p\000\001SW\000\000\r\0358\000\000ik@\000\006N\\\000\0004u`\000\003'.\000\000\032%@\000\001SO\000\000\r\0358\000\000ik@\000\006N\\\000\0004u`\000\003'.\000\000\032:p\000\001SW\000\000\r\0358\000\000iT\000\000\006LL\000\0004u`\000\003%4\000\000\032) 0\000\000\000\000\000\000\000\000\000\010\004\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000 \000\000\004\000\000\000\002\001\000@ \020\010\004\002\001\000@\010\004\000\000\000\000\000\000p8\034\016\007\003A`p8\034\016\007\003A`p8\034\016\007\003A`p8\034\016\007\000\000\000\000\000\030\000\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\000\000\000@\000\000`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001@`0\n7K9ha<\010\014W\023I^r\027\000\000\000\002Ado3\\L\026i\001Fo:[NF+H@u7\031\014V3%\\e2\013@\000\0029jm1\031.\"\003=jt\020\033lb\003IBn3Y%`\000\000\000\000#\033nVs\020@e7\031\005V{\030Zf4[\014R\003%\\s:\031,\026!\001^f\020\011oR98\000\000\000\023nW!\001^f\020\033,Vk=dy\027\000\000\004k%fs4[Lr\001\035v'\027\000\000\000\000\001\034o\020\034nG\023%\\g\020\031m\0273\025\\.\000\000\000\000\002\rBn7\033nB\003=`e7\010\r\026sAjt\020\031M\026c\024\\\000\005\016d\002Q(T*\025\nE\"Q\001&o:\\L6)h@%9B@\002)YH \020\000\000\000\001\024`4<\000\000\000\000\000J0\031\036\000\000\000\000\000%\026M\0162\001\024Z1\034\\`\000\002M^u9\030lR\003\031Rl2H\0146{9ha4[N2\003%Xl2Yl\026a\001Fh0\\L\026\033QJr\027\000\n7#IBn3Y)\026sAjt&[lF(\000\000\000\000\024.V{QJs\020\034nFK1X 7\\\014Vq\001Bt\020\031-f!\001^f\020\033\r\026s\024\\\000\000\000\010v\013IDa3Y$\006#\005ha\020\030.B\003\025\\d\020\033lb\003Mha:\031-V+9h.\000\000\000\005;IRt4[Lr\003Q^ 6\032,'\023\005dy\020\033Mw!\001fu8\034\rw\023QJd\027\000\000\000\001\011\002C&Q$\"\003\025\\v4\\Mvs5Jn:\010\016f\013IRa1\033\014R\0039^t\020\031Mw+9H.\000\000\010fK1J 7\030-V)\001bu7]\014W\031\001\\o:\010\014f{U\\d\020\n\004\"\021\001^r\020\017\007bI8\000\000'\033d\0063%Xe\020\033L\026k\024@g4]LVq8\000I6\033\014V;\005X 8\033n7#\031Rx\027\000\000\000\000\000xn7[LSp\000\000\000\000p.@\000\007\003\\\000\0008'\000\000\003C\026\000\000\034\032\000\000\001aV\000\000\016\004\020\000\000p{\000\000\007\007l\000\0009\034\000\000\003J\024\000\000\034\\@\000\001e_\000\000\016-H\000\000r\\@\000\007\022<\000\0009-\000\000\003L$\000\000\034~@\000\001h\016\000\000\016C\010\000\000tC\000\000\007$\000\000\000:\030\000\000\003O2\000\000\035\0130\000\001i\034\000\000\016x`\000\000wS\000\000\007@\010\000\000<\r \000\003_x\000\000\035{@\000\001nk\000\000\016}8\000\000x\030\000\000\007Ld\000\000<l`\000\003h(\000\000\036H \000\001t\011\000\000\017\036H\000\000y<\000\000\007O\020\000\000=\003`\000\003n$\000\000\036u@\000\001x\010\000\000\017CX\000\000|\001\000\000\007_\010\000\000=\\ \000\003o:\000\000\037\006`\000\001{\027\000\000\017[\010\000\000~\006@\000\007r\000\000\000?\001`\000\003wN\000\000\037.`\000\001{b\000\000\017cXo9\032,vK9Bl\000\000\000\000\003\021Jf4[M\027#%^n\000\000\nF{<@d2Y.\006cd@n2\\nF+\020\\ )\031,7+Ifi;\031$\006k\005Fr7H\0146\0131Xs\037@\000\000\0025Bc9\033d\006s=h 2\031,fK9Jd\020\n\rw\021\001nr7[Lr\003MRg7\030.G+IJ)\027\000\011V\013\rdo\000\000\000\004k\005Fr7H\016\006\013IBm2]\014W\021\001hw4XlRp\000\000M0Xn&y\001Bl9\031,\026#d@d2YM\026s\025H.\000\000\011\026c1Jg0[\004\006\033=Zb4[L\027#%^n\020\033lb\003\r^m6X-f!\001Bn2\010\016\006{Mhf4^\005`\0029Jg0]\r\0273\024@v0[\016V)\000Z 1X-fs=h 1Z\rv{MJ 0Y\014G\023\025fs4[Lr\0035^d2K@\004\013Mfe6XMFK9N :[N7#\005Dl2H\010\024r\024@#'\023ieR\025$O\020\032-g\033Qdu1]\r\026{8\000\000\000\000\010\027\033MJm1\033\r\026s\034@u7\034nF\013\011Xe\020\023\013\004\011\000FN'SK$*I\036 4[N7#Ijc:\032-vp\000\000\000\000\020.7\033\025Zb6\032-f9\001Du3Yo\022\002)\032P\024\011\017\007C\031L)\020\032-g\033Qdu1]\r\026{8\000T0\\Lv+P@n7]\004\006K8@b0[M2\001 `x\022[\017\002I8\000T0\\Lv+P@o:]\004\006{\030@r0[Lv)\000P%6\031\0072\001\025Xd\020\035\rvy\001La9\n%`\002%Xl2Yl\026b\035do:\\\011\026s\021Jx\000\000\000\006{IB\0000Y\0140\003Mha\000\033\014F\010\001Fm8\000\0166\023\014\000p2Z \006S5`\0005\034n \003)Zl\000\032N6`\001Zv8\000\rW38\000p2\\@\006\033=`\0009\031.\000\003MJp\000\034\014V\010\001`h2\000\016F\033L\000p6\031\000\007#MF\000;Y\rP\003APk\000\035\0146 \001dt6\000\016F#\014\000p4\030@\007#ar\0008\033\014 \003Qrx\000\036\014&\010\001pc2@\0167#@\000w0Z \006\023%h\0002\031,0\003%\\c\000\034\r\007H\001`l<@\016\006C`\000p6\036\000\007#MD\000:\034L \003Mhz\000\034l\026\030\001fi9\000\014\026s\014\000s6\033`\007\0231B\0009\\LP\003Ida\000\034l\027@\001Xa<\000\014F\033@\000i9X`\006c\005f\000:\030.0\003MPa\000\034m\007@\001fh<@\014\027\023H\000s1\036\000\006#=`\000:\033n\000\003)Bm\000\030-f(\001Xx0@\016&{0\000s:\036 \007\033Qp\0006\031\017\020\0031Hx\000\030n\007H\001Fp<\000\014'\0030\000b6Z \006\023YF\0001\035N0\003\011Fc\000\030L7\030\001Dn2@\014&+D\000b9\032`\007\003!`\0001[\0140\003AXp\000\034lV\030\001dt4@\016\006C\004\000c6\032 \007\023Qf\0008\033\014\020\003MJi\000\031\014WH\001hx0@\016GK\004\000t<\034`\007#\005r\000:\030/\000\003\rXv\000\035\0167@\001Rn<@\014F+`\000c6\031\000\006K9p\0007\033n\000\003MJd\000\000\000!/@\000\002\n\177\000\000\020Wx\000\001\005?@\000\010+|\000\000BZ\000\000\004\025r\000\000!/p\000\002\n\177\000\000\020Wx\000\001\005?@\000\010+|\000\000B_`\000\004\025~\000\000!/p\000\002\n\177\000\000\020Wx\000\001\005?@\000\010+|\000\000B_`\000\004\025~\000\000!/p\000\002\n\177\000\000\020Wx\000\001\005?@\000\010+|\000\000B_`\000\004\025~\000\000!/p\000\002\n\177\000\000\020Wx\000\001\005?@\000\010+p\000\000B_`\000\004\025~\000\000!/p\000\002\n\177\000\000\020V@\000\001\005<@\000\010.D\000\000By@\000\004\027L\000\000!<`\000\002\013f\000\000\020Z \000\001\005j\000\000\010/\030\000\000By@\000\004\027L\000\000!<`\000\002\013f\000\000\020^0\000\001\005s\000\000\010/\030\000\000By@\000\004\027L\000\000!<`\000\002\013f\000\000\020^0\000\001\005s\000\000\010/\030\000\000By@\000\004\027L\000\000!<`\000\002\013f\000\000\020^0\000\001\005s\000\000\010/\030\000\000By@\000\004\027L\000\000!<`\000\002\013Q\000\000\020^0\000\001\005s\000\000\010/\030\000\000By@\000\004\026H\000\000!:@\000\002\013`\000\000\020^h\000\001\005v@\000\010/4\000\000B{ \000\004\027.\000\000!<0\000\002\013m\000\000\020^h\000\001\005v@\000\010/4\000\000B{ \000\004\027Z\000\000!=P\000\002\013m\000\000\020^h\000\001\005v@\000\010/4\000\000B{ \000\004\027Z\000\000!=P\000\002\013m\000\000\020^h\000\001\005v@\000\010/4\000\000B{ \000\004\027Z\000\000!=P\000\002\013m\000\000\020^h\000\001\005v@\000\010/4\000\000Bx\000\000\004\027Z\000\000!=P\000\002\013m\000\000\020^h\000\001\005k@\000\010/\014\000\000CE\000\000\004\034L\000\000!i0\000\002\016i\000\000\020ih\000\001\006p@\000\0108\030\000\000Co`\000\004\036h\000\000\"\000`\000\002\020\001\000\000\021\000x\000\001\010\007@\000\010@<\000\000D\003`\000\004 \036\000\000\"\001p\000\002\020\017\000\000\021\000x\000\001\010\007@\000\010@<\000\000D\003`\000\004 \036\000\000!\177P\000\002\020\017\000\000\021\000x\000\001\007|@\000\010@<\000\000D\003`\000\004 \036\000\000!~P\000\002\017q\000\000\021\000x\000\001\010\007@\000\010@<\000\000D\003`\000\004 \036\000\000\"\001p\000\002\020\017\000\000\021\000X\000\001\010\007@\000\010@<\000\000C{ \000\004 \036\000\000\"\001p\000\002\020\017\000\000\021\000x\000\001\010\007@\000\010@<\000\000D\003`\000\004 \036\000\000\"\001p\000\002\020\017\000\000\021\000x\000\001\010\007@\000\010@<\000\000D\003`\000\004 \036\000\000\"\001p\000\002\020\017\000\000\021\000x\000\001\010\007@\000\010@<\000\000D\003`\000\004 \036\000\000\"\001p\000\002\020\017\000\000\021\000x\000\001\010\007@\000\010@<\000\000D\003`\000\004\037\026\000\000\"L@\000\002\0248\000\000\021!P\000\001\n\010@\000\010M \000\000D{\000\000\004),\000\000\"Y0\000\002\025G\000\000\021+X\000\001\n[\000\000\010V@\000\000E4\000\000\004+ \000\000\"Z\000\000\002\025P\000\000\021-\000\000\001\nh\000\000\010V@\000\000E4\000\000\004+ \000\000\"Z\000\000\002\025P\000\000\021+\020\000\001\nh\000\000\010V@\000\000E+@\000\004+ \000\000\"Z\000\000\002\025P\000\000\021*P\000\001\nS\000\000\010V@\000\000E4\000\000\004+ \000\000\"Z\000\000\002\025P\000\000\021-\000\000\001\nh\000\000\010U\010\000\000E4\000\000\004+ \000\000\"Rp\000\002\025P\000\000\021-\000\000\001\nh\000\000\010V@\000\000E4\000\000\004+ \000\000\"Z\000\000\002\025P\000\000\021-\000\000\001\nh\000\000\010V@\000\000E4\000\000\004+ \000\000\"Z\000\000\002\025P\000\000\021-\000\000\001\nh\000\000\010V@\000\000E4\000\000\004+ \000\000\"Z\000\000\002\025P\000\000\021-\000\000\001\nh\000\000\010V@\000\000E4\000\000\004+ \000\000\"Z\000\000\002\024v\000\000\021N\010\000\001\014b\000\000\010e\034\000\000F'`\000\0041F\000\000#\007p\000\002\031s\000\000\021U\020\000\001\r'\000\000\010j\014\000\000FO@\000\0045.\000\000#*p\000\002\032W\000\000\021U8\000\001\r+@\000\010j\\\000\000FU`\000\0045.\000\000#*p\000\002\032W\000\000\021U8\000\001\r+@\000\010i8\000\000FU`\000\0045.\000\000#% \000\002\032W\000\000\021U8\000\001\r+@\000\010ih\000\000FH\000\000\0045.\000\000#*p\000\002\032W\000\000\021U8\000\001\r+@\000\010j\\\000\000FU`\000\0044l\000\000#*p\000\002\032W\000\000\021S\020\000\001\r+@\000\010j\\\000\000FU`\000\0045.\000\000#*p\000\002\032W\000\000\021U8\000\001\r+@\000\010j\\\000\000FU`\000\0045.\000\000#*p\000\002\032W\000\000\021U8\000\001\r+@\000\010j\\\000\000FU`\000\0045.\000\000#*p\000\002\032W\000\000\021U8\000\001\r+@\000\010j\\\000\000FU`\000\0045.\000\000#*p\000\002\032W\000\000\021U8\000\001\r\000\000\000\010{\004\000\000GQ\000\000\004<N\000\000#cp\000\002\035c\000\000\021kx\000\001\0179@\000\010~H\000\000Gs@\000\004?\006\000\000#w`\000\002\037W\000\000\021}8\000\001\017k@\000\010~\\\000\000Gu`\000\004?.\000\000#zp\000\002\037W\000\000\021}8\000\001\017k@\000\010~\\\000\000Gu`\000\004>\\\000\000#zp\000\002\037W\000\000\021zP\000\001\017k@\000\010~\\\000\000Gu`\000\004>t\000\000#t\000\000\002\037W\000\000\021}8\000\001\017k@\000\010~\\\000\000Gu`\000\004?.\000\000#zp\000\002\0376\000\000\021}8\000\001\017k@\000\010}H\000\000Gu`\000\004?.\000\000#zp\000\002\037W\000\000\021}8\000\001\017k@\000\010~\\\000\000Gu`\000\004?.\000\000#zp\000\002\037W\000\000\021}8\000\001\017k@\000\010~\\\000\000Gu`\000\004?.\000\000#zp\000\002\037W\000\000\021}8\000\001\017k@\000\010~\\\000\000Gu`\000\004?.\000\000#zp\000\002\037W\000\000\021}8\000\001\017k@\000\010~\\\000\000G`\000\000\004GH\000\000$8`\000\002#(\000\000\022\031x\000\001\0211\000\000\011\011X\000\000H}@\000\004I2\000\000$JP\000\002$I\000\000\022$ \000\001\022/\000\000\011\022x\000\000I\027@\000\004I<\000\000$K`\000\002$^\000\000\022%p\000\001\022/\000\000\011\022x\000\000I\027@\000\004I<\000\000$K`\000\002$4\000\000\022%p\000\001\022/\000\000\011\021@\000\000I\027@\000\004I<\000\000$K`\000\002$@\000\000\022\"(\000\001\022/\000\000\011\022x\000\000I\027@\000\004I<\000\000$K`\000\002$^\000\000\022%p\000\001\022\036\000\000\011\022x\000\000I\027@\000\004Hp\000\000$K`\000\002$^\000\000\022%p\000\001\022/\000\000\011\022x\000\000I\027@\000\004I<\000\000$K`\000\002$^\000\000\022%p\000\001\022/\000\000\011\022x\000\000I\027@\000\004I<\000\000$K`\000\002$^\000\000\022%p\000\001\022/\000\000\011\022x\000\000I\027@\000\004I<\000\000$K`\000\002$^\000\000\022%p\000\001\022/\000\000\011\022x\000\000I\027@\000\004I<\000\000$@@\000\002(g\000\000\022DP\000\001\024\026@\000\011!\024\000\000Iz \000\004O\n\000\000%\017\020\000\002)X\000\000\022M \000\001\024d@\000\011&\020\000\000J7 \000\004S:\000\000%\033P\000\002)]\000\000\022Mh\000\001\024n@\000\011&t\000\000J7 \000\004S:\000\000%\033P\000\002)]\000\000\022Mh\000\001\024Z\000\000\011&t\000\000J7 \000\004R`\000\000%\033P\000\002)]\000\000\022Mh\000\001\024`\000\000\011%\030\000\000J7 \000\004S:\000\000%\033P\000\002)]\000\000\022Mh\000\001\024n@\000\011&t\000\000J/\000\000\004S:\000\000%\033P\000\002)8\000\000\022Mh\000\001\024n@\000\011&t\000\000J7 \000\004S:\000\000%\033P\000\002)]\000\000\022Mh\000\001\024n@\000\011&t\000\000J7 \000\004S:\000\000%\033P\000\002)]\000\000\022Mh\000\001\024n@\000\011&t\000\000J7 \000\004S:\000\000%\033P\000\002)]\000\000\022Mh\000\001\024n@\000\011&t\000\000J7 \000\004S:\000\000%\033P\000\002)]\000\000\022H0U9Z-f9\001^v2\\N6KiJd\020\030,F#IJs9Z-f9\001Zo2\031%`\000\000\000\000$[\rF+\035Bl\020\030mvk\011Rn0]\r\026{8@o3\010\0146{5Za7\031\004\006\0139H 0Y\014G\023\025fs4[Lr\0035^d2K@\000\000\000\000\000\000\000\033@\006p\000\000\000\000\000\000\000\000\000\000\000\000\017@\003p\000\000\000?\000\000\000\000\000\0006\000\000\000\0030\000l\000\000\000\000\000\000\000\000\000\000\000\000\0020\000\000\000\010\000\000\000\001\030\000\000\027\011@\000\0018\000\000\000\004\"\000\000\000\"\000\000\000\000Q)\024j\000\000\000\000\000\000\000\000\000\000\000\000\001h4\000\000\000\000\000\000\000\000\000\000 \001@\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000P(X\016\000\000\000\000\000\" \000\000\000\001Bq\000\0014[/\027\000\000\000\0258X\000\000\000\000\014H \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004X\000\000_-@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001;\000&`\011p\000\000\000\000\000\000\000\000\000\000\036\013\017FerY|v\000%\000\000\005rh\000\000\000\000\000\000\003=V\177=@\000\000\000\000<\0327ZowZ<t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004p\000\000\000\000\000\002a\020\034\006\027\011Id39M\014B#Pje\022]&f1\035N&;\rns\003\000A`PX$g1]n4qH\000\001\000\000\000\000\003h\000\000\000\000\000\000\000\000\000\000\000\000@`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\\nW;ev}?\\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016'#Ypz>\037N\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\023\031Tn9\035O's\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001Hh6\034\016GCq@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\014J'\024JeRy\004F%\023J%2i<Z@\000\000\000\000\000\000\000\000\000\000\000\000\004J)\026H\002SItB%\024K$\001)dz!\022J%R\000Tr=\020\000\000\000\000\000\000\000\000\000\000\000\000\000\004&\025\013F#1h|\"\023\nEc\021Xt>\021\011E\"qHl:\037\010\000&3)\\`\013\036Og\023\000\000\000\022\n\005C\001Pp<\020\011\005\002a@h8\036\010\004BA0`4\034\017\004\000\003\021Pl8\035\017\007c\000\000\000\001H\000r\000,@\017\020\004d\0019\0006 \017H\0002\000\034@\013\020\003d\001\031\000. \rH\003r\000\014@\007\020\002d\000y\000& \013H\0032\000|@\000\000\000l\000;\000\026`\007X\000\001\027_m{0\007l\001\037\000\000\000\001hT\000\000\036M \000\002u*\000\000\037.P\000\002;\025\000\000\027[(\000\001]j@\000\017oT\000\000\016E \000\001tj\000\000\027*P\000\001zu\000\000\023Y(\000\001=Z@\000\rnT\000\000~} \001xt*\000\037O&P\002}:U\000\037oW(\002?\035J@\027{mT\001_nu \017\177wj\000\000\000\000\000\000\000>\027\000\000\007s8\000\000_+@\000\007{\\\000\000\000\000\000\000\000\000\000\000\0007zp\000\003\177w\000\000\000\000\000\000\000\r\002@\000\002i\024\000\000&Q \000\0035J\000\000#0P\000\002[%\000\000\031\\(\000\001mr@\000\000h\024\000\000\026I \000\0025\n\000\000\033,P\000\002\033\005\000\000\025Z(\000\001Mb@\000\016o\024\000\017\006A \002y4J\000'S(P\003=Ze\000#qX(\002_-R@\031|n\024\001ovy \000\000\000\000\000\000\003`p\000\000^'\000\000\011t8\000\000o3@\000\010|\034\000\000Wi`\000\006?\016\000\000;|p\000\000\000\000(\034Mv#UFe2\010\016F{<@m:Xm\002\003\r^d2K@\005\033\025Nm2[NB\003IJa1Z\014V!\001Bn7]\r\006+H@o7\031%B\003=le9\035n&KQRn3H\r\027!8\000\000\000\000\011V+5^r<H\014\026cIJa2\036$\006K9Rt4X-FKMJd\027\000\011w+Q`u:\010\014fK1J 0[\016&+\005Hy\020\030m\006{MJn\027\000\n6\013YRn3H\004Vc\020@(\030\036\004Vc`R 1\036.F+L@(\030\036\004Vc`@-\020\014\017\002+1p 2^\0146cUfi;\031%\022p(\000\000\000\000\n6+\035Ze7\035\004\007\033%te\020\032.2\001\025Xd\020\n\006\007A\025Xx\024H\014'KQJs\020\n\006\007A\025Xx\020\013$\003\003`Jl<\010\014WC\rXu9Z.f)$\\\n\000\000\000\005\033\025Nm2[NB\003Mha9\035\0162\003%\\s4Y\014R\003\005\\o:\032\014W\021\001^n2K\004\006{YJr;\\M\027#%\\g\020\032.Bp\000\000a8\034\rF(\000\000\0008\033\014\026K8\000\000\000\020(4j\024\000\000\000\000\004\"\013\rDm\021\010\r\027\031\001^b9[mF+QJ;\020\035.6)\000D!1]\004\007\003\025h\"\020\032-g\033QJa2\013@\000\001\024\\3\030\031`\000\000\000xU'\021\010T2%\034E\"\010\010db=\002T\037\000\000\000\001\025Xd\020\n\006\007A\025Xx\024@\007E*9\010E#\022)d*\020@I'\025\007`\001\005fe9\032-w+Lt \000\000\004\026+Ido9\016D\000\000\000\000\000\020]l\027\0238t \000\021Mw+9H 7\031.r\001\010Bf7\\D\"\003Mrn:\030/\002p\000\000\000\000\025n&{9N :\036.\006)\001Lo9\010\rF{=`'9H\010Tr\020@v0[\016V)\000Z 6].7!\001Za:\030m\002\003Qrp2H\rv1\001&T TJB\003YBl:Y%`\000\000\000F7]-f!\001^l2\010\004\"\013\031^r\021\010\0167K9ha<\013@\000\000\000\000L7[n\002\003\r^u7\035\004\006KL@n2Yl\027#%le\027\000\n7+\011to7\031 \005+9Vn7]mb\003Ado1Y.7\033=d.\000\000\011f+\035Bt4]LR\003MRz2H\014\027\023\035jm2[NBp\001 a2\031\r\026s\034@w4]\r\002\003iJr7Y.2p\000\000\000\000\023\rv\013\021Jd\020\011,B\001 `x\022L\006GA$@b<]\014W\031\001Lr7[$\0063%Xe\020\033lf3MJt\020\011-F!\000P0<\011&\003#1p)\027\002@\000\000\001(o7H\014F+\025`l<H\rf+Mhe2\013D\005\023\025Fu9\034m\0273\024@\"\020\\mw+IFe\021\017`\005\033eZb7[\004\006c%ft\020\031M\026c\024@n0[,R\003\005Xr2X,GI\001Fh7\\lVq8\000\000\000\025.6+\020@\"\020]\rr\021\001ni:\032\rw+P@f4[\014R\003\031^r6X.B\003%\\d4Xl\027#=d.\020\021\014V3\005jl:\032-f9\001ho\020\010L6\0234D.\000\000\nVs-\\o;[D\006{Uhp:]\004\0063=dm0]\005`\000\000D!9],'S=\\e\020\036oR\021\001Rs\020\033l'\033=Xe:\031'2\003Ufe\020\010D\027S=\\e\020\036oR\021\001Rn9]\014V\013\020\\\000\000\033nf+IXa<@\r\026sYRs4XMF(\000\000\000*[M6s=nn\020\010E\"\001tD 9Y,vk\025\\t\020\033-v#%Li2\\E`\002U\\k7\033nvq\001`s2],Fy\001^p1[lF)8\000\000:\033`\000\003\011r\000\000\030O\027#\024\000\000\000\000\016vx\000\000w7\\L@\000\000\000\000\031\r\000\000\001Ld\000\000\030n@\000\001Fo7\035NF\013\010\000t<\000\000\007#\025pt\000\000\000\000\003\011Rn\000\030M\026s\005dy\000\000\014fH\000\000f4[\r@\000\000\000\0000[\r\026;8\000\000\000\034\0166+UHo8\030`\000\000\000\000r2X-G\003\014\000\0000[\000\000\003\005f\000\000\034N0\000\001fe:\000\017&p\000\000s=\000\000\007\033IF\0009[nW\023\rJ\000\000\032,`\000\001Rf2\031,`\000\000\000i3\033LF+\030\000\0003\033n \003\021^\000\000\033,\026\033I^\000\000\000\016v\013I\\\000\000\000\000\007\033\025di7].0\003\025^f\000\031-f#=Lf4[\014P\000\000\000\"\020\\\0166+UHo8\030er\013IJa6\034\0142\021\001Rs\020\033l'\033=Xe:\031'2\003Ufe\020\010D\027\003MJu2\033n\006\031\001v}\021\010\r\026sMhe0Y\005`\000\000\000\0002\035.&K9N\000\000\032-fKP\000\000\000\000\014\026a\001\006:\022L\006GA\000\\%9B@\000\001\005Bd2\034@\000\000\000\022%9@\0053\020$z \000\000\000\002YL\022=\020\000\000\000\000$z \000\011%c\031AL\000\000\000\004B+`\000 \037@\000\000Il@?\000\000\000\000\000$v :[NW\033\025H\000\000\000\nF{<@l0]\014R\003\031^r\020\034\rw\033QLi<\013@\000\000\001&y6XMva\001Bl9\031,\026#d@d2YM\026s\025H.\000\023\014\026\023\025X 7\030-V)\001\\o:\010\r\026q\001Xe3\035\rV{Mh 1[mG+5\\.\000\000\nw\023=\\g\020\035\017\027\003\024@-\020\031/\007\003\025Ft2Y\004\006K9he3Y.\"p\000\000W9\033mf9\001hy8\031$\002i\001Jx8\031,7#\025H 0Y\014G\023\025fs\027\000\000\000\000\000\000\000\036\036E7y\010^eq\017\020\0321\030f\024.\001gG\000\036\020zx2wSdFL&\031E\013@9\177;,3A,\033Z<\177i\020~jD!40?w\\a=\024\007m\033\037~$\037ZQ\010-\014\030,6{L\000\000\000\000\014\027\033%\\\000\000\000\000\007\003=n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000|L~zh<~@\014\000\000\000\000\000\000\000\000\000\037xW\000\032\000\000\000\000\017~\000\000\000\000\000\000\000\007\177@\000\000\000\000\000\000\003\177dC{ \002$\037Z\000%Y>\020\003\022\017m\000\0375\036H\002\026ex@\022\17774\001$C{ \013\010cR\000^j=\020\006\024:q\0002l_\010\003#.8@\032\17774\001^\037[ \016$\037Z\000u4\rP\007D1i\000=l\026H\003{)t@ \037ID\002\005\016\\ \020B\006b\001\005Y>\020\010:\0241\000D5g\010\004)RX@\"\17774\002\033\rK \021q}Z\001\020XuP\011\022\017l\001\"|``\006r9\010\000\nJ?@\001\035/Q\000=&Mh\003\001[1\000\022YIp\000CH\020 \017rEF\000UwW0\006\025C7\000\011\rcP\001\004Mi\000\034\0002$\000.u\002 \r\014H8\000\177\007=0\000rb)\000)gn@\002\0045z@\005kZ\020\001\004tg\000\007\001\032h\000/_H\020\001f#V\000\01605\030\000stN\000\020E|,\001=|J\000\003X\177p\000K\177{`\000\0260\017\000;eq\010\002\026Z\005\000\rQ{4\0006?3`\002>,\022\000[Sh`\001}M\036\000\027}\"h\001j']\000\030~_\024\001q=O \0009gn\000E\024R \007)W{\000\027v\021x\002\032]\004\000\n`\031@\000F~\036`\006]/`\000go\004\000\004kh6\000\0075\036\030\002\"a/\000\034aX \000eLa \005xR@\0004\020\021P\007\1771\000\000\023.28\000b\006\003\000\002U6(\000sT2 \006\007\011v\000`#\r3\177dC{ \000\000\000\001yhD\026@\000\000\000\000yx#&\020\000\000\000\000;<3\n\026\000\000\000\000\034|\0038\034\000\000\000\000\016\017\")\001\000\000\000\000\006n\034\010E\000\000\000\000\003+'f\035\000\000\000\000\000\000\000\000\001\000\000\000\000\014\000\000\000\001\000\000\000\000\014C\030\000\000\000\000\000\000\000aL\000\000\000\000\000\000\000\020`\000\000\001\022N#\000\r\026s\030\000N S@\006s\005\\\000\030\014&#\031Pj6\033N\007\024\n\011\006D\"Q@\000\000\000\0000\030LF3!Tl7\034\016,\026\023\rHe3\000\000\000\000\000Pn:[\rBH\000\0000\000\000\000\000\000\020\1770\000\001\010R`\000\010E\026\000\000D\022p\000\004\"K\000\000\"\024X\000\002\021%@\000\021\n,\000\001\010R`\000\010E\026\000\000CNP\000\004\035*\000\000\"\024X\000\002\016>@\000\020\177H\000\001\010R`\000\010@\024\000\000D\001`\000\004 \016\000\000\"\000p\000\002\020\007\000\000\021\0008\000\001\010\003@\000\010@\034\000\000D\001`\000\004 \016\000\000\"\024X\000\002\021%@\000\021\n,\000\001\010R`\000\010E\026\000\000D)0\000\004\"K\000\000\"\024X\000\002\021%@\000\021\n,\000\001\0101\000\000\010CZ\000\000D)0\000\004!m\000\000\"\024X\000\002\021%@\000\021\n,\000\001\010R`\000\010DB\000\000D)0\000\004\"K\000\000\"\001`\000\002\021%@\000\021\n,\000\001\010R`\000\010E\026\000\000D)0\000\004 E\000\000\"\024X\000\002\021%@\000\021\002P\000\001\010R`\000\010E\026\000\000D)0\000\004\"K\000\000\"\024X\000\002\021%@\000\021\n,\000\001\010R`\000\010E\026\000\000D)0\000\004!\005\000\000\"\007\000\000\002\020v@\000\021\0074\000\001\010; \000\010B\002\000\000D\016\000\000\004\"K\000\000\"\024X\000\002\0168@\000\021\n,\000\001\010&`\000\010Dl\000\000D\025p\000\004\034q\000\000\"\024X\000\002\016W\000\000\021\n,\000\001\010I \000\010E\026\000\000D)0\000\004![\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001\000@ \020\010\004\002\001\000@ \020\010\004\002\001\000@\000\002\031\026\000\000\021T\020\000\001\r!\000\000\010dd\000\000FP@\000\0045\004\000\000#( \000\002\032B\000\000\021T\020\000\001\r!\000\000\010^\024\000\000F\000\000\000\0045\004\000\000\"y\020\000\002\031\033\000\000\021T\020\000\001\014j \000\010f\014\000\000F0`\000\0043\006\000\000#\0300\000\002\031C\000\000\021L\030\000\001\014a@\000\010f\014\000\000F0`\000\0045\004\000\000#( \000\002\032B\000\000\021T\020\000\001\r!\000\000\010j\010\000\000FP@\000\0045\004\000\000#( \000\002\032B\000\000\021Q \000\001\014p@\000\010j\010\000\000F8 \000\0045\004\000\000#( \000\002\032B\000\000\021T\020\000\001\014}@\000\010j\010\000\000FP@\000\0042N\000\000#( \000\002\032B\000\000\021T\020\000\001\r!\000\000\010j\010\000\000F.p\000\0045\004\000\000#( \000\002\031}\000\000\021T\020\000\001\r!\000\000\010j\010\000\000FP@\000\0045\004\000\000#( \000\002\032B\000\000\021T\020\000\001\r!\000\000\010j\010\000\000FB`\000\0043\024\000\000#\034\020\000\002\031a\000\000\021N\010\000\001\014i \000\010f(\000\000FP@\000\0045\004\000\000\"x0\000\002\032B\000\000\021R(\000\001\r\027@\000\010fZ\000\000Ep`\000\0045\004\000\000#\000 \000\002\032B\000\000\021S<\000\001\r!\000\000\010j\010\000\000FG\000`0\030\014\006\003\001@`0\030\014\006\003\001@`0\020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010\nt\nI\034I'\021g\"\003ABt4\030mvs\030t *[M6s=nn\020\010Mf\0135J\"\035\010\004V (\000\000+P*$r%\034G\035\010\0167KMFt6\016D\005+9Vn7]mb\0039Bm2ND\002+\020\024\000\000\013lF+X^c7[N6{1J\000\000\000\000\002+T\\%:KDW)8Ju\000\025-f[9^w7\010\010W\023I^r\000\000\000\002+Lt \022\\a \001=Jt1Klw\023=jp\000\000\004UZxt]\035\011+5qi::\022Z\016P\001=Jt1Kn\006\013Mfw2\000\004UZxt]\035\011+5qi::\022Y\007\"+\020t%-WG%ihJ[/\016KSQ\025f\n\000\000\000\005*M\nR\000\000\000\000\001<\000\000\000\013lF+X^n:[\r@\000\000\000N7H\010W\023I^r\000\000\000\000\002U\\k7\033nvq\001Po9]\000\000\000\000\000H7\\nB\0039Bm2H\rF{=Vu8\010\014f\013%Xu9\031 \000\000\000\000U7\032mf{]\\ 9Y.'3\025d 2\\N&{H\000\000\000\000\011fy\001Bd2\034LW\033L@a9\\mv\033%Bt2Y\004\007;%hh\020\033L\026k\024\000\000\003A @\000\034\n\020\000\001`R\000\000\016\005\036\000\000p*P\000 \020\010\004\002\001\000@ \020\n\005\002A P \020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010\004\010@@ \020\010\004\002\001\000@ \020\010\004\002\001\000@\010\004\002\001\000@ \020\010\004\002\004\002\001\000@ \020\010\020(\024\n\005\002A\000@ \020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010\004\002\020\010\004\002\001\000A\004B!\020H$\020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010\004\002\001\000@!\000@ \020\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\004\002\001\000@ \020\010\004\002A P(\024\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010\004\002\001\002\020\020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\002\001\000@ \020\010\004\002\001\000A\000@ \020\010\004\002\004\n\005\002A P \020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010\004\002\001\000D\002\001\000@ \020!\020H$\022\011\004\002\001\000@ \020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010 \020\010\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\022n3\032-fKQr\000\000\000\000\004s\005\034\000(\023j4J`\000\000\000\000\000\000\000\024\000\000\000\006 \000\000\001z<N4V)>b\023<\034R>b\036VQ'\031LTP\177u\011tSO$U]h\021OF%sPV \014(2+\rt\032\r\003C<M|\010\000\001\r\023\\-6P+8.M\034\023`>I\177su- NtGd`\035\031\035\"T~u~s_O\007\177\000\000\000\000\000\000\000\004\001\020\000\000\000\000\000\000\002\0012\000\000\000\000\000\000\001\001\017 \000\000\000\000\000\000@ab\000\000\000\000\000\000 >\r \000\000\000\000\000\020%h$\000\000\000\000\000\010\026\030K \000\000\000\000\004\014_/\004\000\000\000\000\002\007\033M2@\000\000\000\001\004\002P\027d\000\000\000\000B\033R\016n@\000\000\000!\033#)%\010\000\000\000\020T#\004sJ@\000\000\010-5s\010\036H\000\000\004\0301Wu\023\r\000\000\002\r\003C<M|\010\000\001\006v\032\025p]E\000\000CUp-V:;\020\000!x+\016#\002\"=\000\021\002Zxuq5F\020\010DXkIVq;j\004$\003aO\003\023:Y\022\022j-\0011|\024WY\011j<\020o\035Lvh\000\003\001o\000\000\030\021\\\000\001A\r`\000\014\011@\000\000`Fp\000\006\0047\000\0000#8\000\003\002\033@\000\030\021\\\000\001A\r`\000\014\003P\000\000`\036@\000\006\0047\000\0000\017\000\000\003\002$\000\000\030\021\\\000\001A\021\000\000\014\010N\000\000`Dp\000\006\004'\000\0000\"8\000\003\002\023@\000\030\021\034\000\001A\011`\000\014\010N\000\000`Dp\000\006\0047\000\0000#8\000\003\002\033@\000\030\021\\\000\001A\r`\000\014\010n\000\000`Fp\000\006\0047\000\0000#8\000\003\002\033@\000\030\020<\000\001A\r`\000\014\010n\000\000`Fp\000\006\0047\000\0000#8\000\003\002\033@\000\030\021\\\000\001A\r`\000\014\010n\000\000`Fp\000\006\003@\000\0000#8\000\003\002\033@\000\030\021\\\000\001A\r`\000\014\010n\000\000`5\020\000\006\0047\000\0000#8\000\003\001\\@\000\030\021\\\000\001A\r`\000\014\010n\000\000`Fp\000\006\0047\000\0000#8\000\003\002\033@\000\030\021\\\000\001A\r`\000\014\010n\000\000`*`\000\006\002E\000\0000#8\000\003\002\033@\000\030\021\\\000\001@P \000\014\005\n\000\000`Fp\000\006\0047\000\0000\016 \000\003\002\033@\000\030\007`\000\001A\031\000\000\014\007\032\000\000`\034@\000\006\0047\000\0000\037\020\000\003\002\033@\000\030\017\020\000\001A\r`\000\014\010n\000\000` p`0\030\014\006\003\001@`0\030\014\006\003\001@`0\020\010\004\002\001\000@ \020\010\004\002\001\000@ \020\010\014R+1H\000\000\000\000\000\000\030/0\000\001BW`\000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030*|\000\001BW`\000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030*|\000\001BW`\000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030*|\000\001BW`\000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030*|\000\001BW`\000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030*|\000\001BW`\000\014\026v\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030C\\\000\001BW`\000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\0108\000\000\030C@\000\001D\034\000\000\014!`\000\000b\016\000\000\006\020p\000\0001\007\000\000\003\0108\000\000\030C@\000\001D\034\000\000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030*|\000\001BW`\000\014\025>\000\000a+p\000\006\n_\000\0000V(\000\003\0106@\000\030*|\000\001D\033 \000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\0105\000\000\030*|\000\001BW`\000\014\027&\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030*|\000\001BW`\000\014\025>\000\000a+p\000\006\020a\000\0000Ux\000\003\005/@\000\030B`\000\001BW`\000\014\025>\000\000a+p\000\006\n_\000\0000Ux\000\003\005/@\000\030*|\000\001D\025\000\000\014\025L\000\000b\rP\000\006\020m\000\0001\006h\000\003\010(@\000\030B\034\000\001BW`\000\014\025>\000\000b\011`\000\006\n_\000\0001\010@\000\003\005j\000\000\030D\024\000\001BW`\000\014\025>\000\000b\020 \000\006\n_\000\0001\007P\000\003\005/@\000\030*|\000\001D\030 \000\014\035\024\000\000aUP\000\006\016J\000\0000t\010\000\003\006V@\000\0308`\000\001C&`\000\014\0326\000\000aS0\000\006\r\033\000\0000iX\000\003\006M@\000\0304l\000\001C&`\000\014\0326\000\000aUP\000\006\r-\000\0000jh\000\003\006V@\000\03054\000\001C+ \000\014\032Z\000\000as \000\006\r-\000\0000jh\000\003\006V@\000\030<\010\000\001C_\000\000\014\032Z\000\000aUP\000\006\016n\000\0000jh\000\003\006V@\000\03054\000\001C+ \000\014\035:\000\000aUP\000\006\r-\000\0000jh\000\003\006V@\000\03054\000\001CU`\000\014\032Z\000\000aUP\000\006\r-\000\0000jh\000\003\007(@\000\03054\000\001C+ \000\014\032Z\000\000aUP\000\006\r-\000\0000jh\000\003\006V@\000\030<h\000\001C+ \000\014\032Z\000\000aUP\000\006\017\002\000\0000w`\000\003\006V@\000\03054\000\001C[@\000\014\032Z\000\000aUP\000\006\r-\000\0000jh\000\003\007.@\000\03054\000\001C+ \000\014\032Z\000\000aUP\000\006\r-\000\0000u8\000\003\006V@\000\03054\000\001C+ \000\014\032Z\000\000aj\020\000\006\017M\000\0000{\030\000\003\007f@\000\030=L\000\001Cl`\000\014\0376\000\000az@\000\006\017T\000\0000} \000\003\007j\000\000\030>P\000\001Cu\000\000\014\037(\000\000b\0000\000\006\020\003\000\0000{\030\000\003\007Y@\000\030=L\000\001Cl`\000\014\036f\000\000av0\000\006\0173\000\0000|0\000\003\007c\000\000\030>\030\000\001Cq@\000\014\037\014\000\000ax`\000\006\0173\000\0000{\030\000\003\007Y@\000\030=L\000\001Cl`\000\014\036f\000\000av0\000\006\0173\000\0000{\030\000\003\007Y@\000\030=L\000\001Cl`\000\014\036f\000\000av0\000\006\0173\000\0000{\030\000\003\007Y@\000\030=\000\000\001Cl`\000\014\036f\000\000av0\000\006\0173\000\0000{\030\000\003\007Y@\000\030=L\000\001Cl`\000\014\037\014\000\000ax`\000\006\017F\000\0000|0\000\003\007c\000\000\030>\030\000\001Cl`\000\014\036f\000\000av0\000\006\0173\000\0000{\030\000\003\007Y@\000\030=L\000\001Cl`\000\014\036f\000\000av0\000\006\0173\000\0000{\030\000\003\007Y@\000\030=L\000\001Cl`\000\014\036f\000\000av0\000\006\017 \000\000P\000\002\000\001\000\0000\000\020\000\005\000\001@\0008\000\020\000\004@\001 \000,\000\014\000\003 \000p\000\036\000\010\000\000\000\000\031\010L\000\001HW`\000\014E>\000\000d#\020\000\006\"_\000\0002\025x\000\003\021/@\000\031\n|\000\001HW`\000\014E>\000\000d\014p\000\006 s\000\0002\025x\000\003\0207@\000\031\005\010\000\001HW`\000\014C\n\000\000d\031\020\000\006!I\000\0002\014H\000\003\020d@\000\031\006$\000\001H2 \000\014C\022\000\000d\031\020\000\006!I\000\0002\025x\000\003\021/@\000\031\n|\000\001HW`\000\014E>\000\000d+p\000\006\"_\000\0002\025x\000\003\021/@\000\031\n|\000\001H5`\000\014E>\000\000d+p\000\006\"_\000\0002\025x\000\003\021/@\000\031\n|\000\001HW`\000\014E>\000\000d+p\000\006\"_\000\0001a@\000\003\021/@\000\031\n|\000\001HW`\000\014E>\000\000d+p\000\006\034\n\000\0002\025x\000\003\021/@\000\031\007,\000\001HW`\000\014E>\000\000d+p\000\006\"_\000\0002\025x\000\003\021/@\000\031\n|\000\001HW`\000\014E>\000\000d+p\000\006!{\000\0002\020@\000\003\021/@\000\031\n|\000\001HW`\000\014B<\000\000d!\000\000\006\"_\000\0002\025x\000\003\016\003\000\000\031\n|\000\001H\035`\000\01482\000\000d&p\000\006\034\006\000\0002\025x\000\003\021\016@\000\031\n|\000\001G\002`\000\014E>\000\000d+p\000\006!\006\006\003\001@`0\030\014\006\003\001@`0\030\014\006\003\001\000@ \020\010\004\002\001\000@ \020\010\004\002\001\000@n3\000\000\006K9Rt<@\000\000\003\005\\\000\000\000\000ff \000\0068\000\000\0003@\000\000\003\034\000\000\000\031`\000\000\001N\000\000\000\014p\000\000\000g\000\000\000\0068\000\000\0003?@\000\003\033|\000\000\031_`\000\001M~\000\000\014op\000\000g\000\000\000\0068\000\000\0003@\000\000\003\034\000\000\000\031`\000\000\001N\000\000\000\014p\000\000\000g\000\000\000\0068\000\000\0003@\000\000\003\034\000\000\000\031`\000\000\001N\000\000\000\014p\000\000\000g\000\000\000\0068\000\000\0003@\000\000\003\034\000\000\000\031_`\000\001N\000\000\000\014p\000\000\000g\000\000\000\0068\000\000\0003@\000\000\003\034\000\000\000\031`\000\000\001N\000\000\000\014p\000\000\000g\000\000\000\0066^\000\0003@\000\000\003\034\014@\000\032\010L\000\001P@\000\000\r\003t\000\000g\024p\000\006B\014\000\0004\020\000\000\003!\011Cds%2Kv\021\033ae\023v\021u5\n9Le%\007\177(O%\034z%-nA\014|2/\035\007\006\000bC\022Xo!@\000i- \000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i\033P\000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i\033P\000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i\033P\000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i\033P\000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i\033P\000\006I]\000\0004T\000\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i_ \000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\033z\000\000i_P\000\006M}\000\0004oh\000\003&~@\000\0327t\000\001S? \000\r\033z\000\000i_P\000\006M}\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i\033P\000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R8`\000\r\023:\000\000i\033P\000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\033n\000\000i\033P\000\006I]\000\0004U\020\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i\033P\000\006I]\000\0004Mh\000\003$n@\000\0327P\000\001R7 \000\r\023:\000\000i]0\000\006I]\000\0004Mh\000\003$n@\000\032&t\000\001R7 \000\r\023:\000\000i\033P\000\006Mg\000\0004N \000\003$n@\000\032&t\000\001R7 \000\r\033H\000\000i[P\000\006I]\000\0004Mh\000\003&m\000\000\032&t\000\001S3 \000\r\025&\000\000iXP\000\006I]\000\0004Mh\000\003&a\000\000\032&t\000\001S.`\000\r\023:\000\000i\033P\000\006Mt\000\0004gH\000\003&\023\000\000\0323d\000\001S\011@\000\r\030L\000\000iIp\000\006LH\000\0004d@\000\003&$\000\000\0322 \000\001S\022\000\000\r\031\020\000\000iI\000\000\006L=\000\0004ch\000\003&\023\000\000\0321\030\000\001S\011@\000\r\030L\000\000iD`\000\006L&\000\0004b0\000\003&\033\000\000\0321X\000\001S\r@\000\r\030l\000\000iF`\000\006L6\000\0004b0\000\003&\023\000\000\0321\030\000\001S\011@\000\r\030L\000\000iD`\000\006L&\000\0004b0\000\003&\023\000\000\0321\030\000\001S\011@\000\r\030L\000\000iD`\000\006L&\000\0004b0\000\003&\023\000\000\0321\030\000\001S\004`\000\r\030L\000\000iD`\000\006L&\000\0004b0\000\003&\023\000\000\0321\030\000\001S\011@\000\r\030L\000\000iF`\000\006L6\000\0004c0\000\003&\033\000\000\0321X\000\001S\r@\000\r\030L\000\000iD`\000\006L&\000\0004b0\000\003&\023\000\000\0321\030\000\001S\011@\000\r\030L\000\000iD`\000\006L&\000\0004b0\000\003&\023\000\000\0321\030\000\001S\011@\000\r\030L\000\000iD`\000\006L&\000\0004a\030\000\005\000\000\020\000\010\000\003\000\001\000\000(\000\014\000\003@\001\000\000$\000\n\000\002`\000`\000\032\000\007\000\001p\000@\000\000 PH4\"\025\014\000\000\030,&\033\021Jf\000\000\006\003\011Hf4\032MFsAd\000\000\000\000\000\000\000\000\000\000\000\000 \020\010\004\002\001",0x1151);
+    private static final int[] _data4 = decodeData("\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006n]\000\0009Ah\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\r]>\000\000s\003P\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033;\004\000\001f\006`\000\000\000\000\000\000\000\000\000\000\000\000\000 \0006v\020\000\003L\014@\000\000\000\000\000\000\000\000\000\000\000\000\000@\000s\0130\000\007\030\021\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001f\026 \000\0160\036\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003L+@\000\034`4\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\007\030[`\0009A8\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\01613@\000s\002P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\034b_\000\001f\004`\000\000\000\000\000\000\000\000\000\000\000\000\000 \0009H\020\000\003L\031@\000\000\000\000\000\000\000\000\000\000\000\000\000@\000s\0170\000\007\0301\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001f `\000\0160j\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\00372\000\000\034aT\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006ne\000\0009B8\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\r]L\000\000s\004P\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\034d\020\000\001f\022 \000\000\000\000\000\000\000\000\000\000\000\000\000 \0009Gr\000\003L'@\000\000\000\000\000\000\000\000\000\000\000\000\000@\000s\017`\000\007\030M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001f\0368\000\0161\026\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\0038-\000\000\034.l\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006p\\\000\0008]@\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\ra<\000\000q:P\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033C\000\000\001bt@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0009H(\000\003Eg@\000\011\034\000\000\000\000\000\027(\000\000\000\000\000$ \000\000\000\000\000\035 \000\000\000\000\001\016@\000\000\000\000\005u\000\000\000\000\000\0040\000\000\000\000\000\027T\000\000\000\000\000\021\030\000\000\000\000\000\036P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\007\030t\000\0009F`\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\0161f\000\000s\rP\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\034cH\000\001f\032aqjn:\032.Fc\025H>\000\000\000\0007\033\030\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:6\000\000\000\002\020\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\007\031\004\000\000\000\004\"\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\0161|\000\000\000\010H\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033S4\000\000\000\021\030\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007&p\000\000\000\002@\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nMp\000\000\000E \000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]\034\000\000\000\001\013\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:8@\000\000\002\027\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006tr\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rif\000\000\000@\014\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033SP\000\000\001\000(\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007'(\000\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nN`\000\000\004\001@\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]\035`\000\000\030\"\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:<\000\000\0000T\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006ty\000\000\000QD\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\0162\000\000\000\001$\010\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033Sh\000\000\000A\030\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007'X\000\000\001\002@\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nO@\000\000\002\005 \000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]\037 \000\000\004\013\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:?\000\000\000\030\013\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006t\177\000\000\00006\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rj\000\000\000\000a,\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033T\004\000\000\001CX\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007(\020\000\000\003\010 \000\000\000\000\000\000\000\000\000\000\000\000\000@\000nP0\000\000\006\022`\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]!\000\000\000\014-@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:B@\000\000\030k\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006u\006\000\000\0001v\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rj\016\000\000\000d,\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033T \000\000\001IX\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007(H\000\000\003\0250\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nQ \000\000\006.`\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]\"`\000\000\014u@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003:F\000\000\000\031{\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006u\r\000\000\00036\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\rj\034\000\000\000f,\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033S0\000\000\000\020@\000\000\000\000\000\000\000\000\000\000\000\000\000 \0009H \000\000\000!\020\000\000\000\000\000\000\000\000\000\000\000\000\000@\000s\017`\000\000\000B@\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]\033 \000\000\001\005@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:7\000\000\000\000\014\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006to\000\000\000\004\032\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\ri`\000\000\000\0108\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033SD\000\000\000\020x\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007'\030\000\000\002\000 \000\000\000\000\000\000\000\000\000\000\000\000\000@\000nQp\000\000\002C`\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]$\000\000\000\004\010\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:H@\000\000\010\021\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\007\031\001\000\000\000B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rj$\000\000\000bh\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033TL\000\000\001GP\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007) \000\000\003\033 \000\000\000\000\000\000\000\000\000\000\000\000\000@\000nRP\000\000\006>@\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]%@\000\000\004\006@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:K@\000\000\010\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006u\030\000\000\000\020$\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\0162\002\000\000\001\000H\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033Td\000\000\000B \000\000\000\000\000\000\000\000\000\000\000\000\000\000\0007)P\000\000\001\004P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000nS0\000\000\002\005`\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]'\000\000\000\000\014@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:N@\000\000\000\032\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006u\036\000\000\000\0006\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rj>\000\000\000\000p\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033U\000\000\000\000\001h\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007*\010\000\000\000\003`\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nT \000\000\000\007`\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001](`\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:R\000\000\000\010 \000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006u%\000\000\000\020B\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rjL\000\000\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033U\034\000\000\000B\020\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007*@\000\000\001\0040\000\000\000\000\000\000\000\000\000\000\000\000\000@\000s\020 \000\000\002\006\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]* \000\000\004\014@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:U\000\000\000\010\032\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006u+\000\000\000\0206\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rjX\000\000\000 p\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033U4\000\000\000Ah\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007*p\000\000\001\003p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000nUp\000\000\002\007@\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]\033\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003LB\000\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\007\030~\000\000\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\riZ\000\000\000\010\014\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033S8\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000 \0007&x\000\000\000 P\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nN\000\000\000\000A@\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]\034 \000\000\001\003@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:G@\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\007\031\003\000\000\000\020\002\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rj`\000\000\000 \010\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\034cl\000\000\000@\030\000\000\000\000\000\000\000\000\000\000\000\000\000 \0009Gd\000\000\001\000@\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nV\020\000\000\002\001 \000\000\000\000\000\000\000\000\000\000\000\000\001\000\001],@\000\000\004\003\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:Y@\000\000\014\007\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006u4\000\000\000\030\020\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rjj\000\000\0000$\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033UX\000\000\000`P\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007)\000\000\000\001\0010\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nR\020\000\000\002\003\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]-`\000\000\020\010\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:\\\000\000\000 0\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006u9\000\000\000A \000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rjt\000\000\001\003@\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033Ul\000\000\002\011\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007+`\000\000\004\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nWP\000\000\0104\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]/@\000\000\020x\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:9@\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006tt\000\000\000 \002\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rj~\000\000\000`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033V\000\000\000\001@@\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007,\010\000\000\003\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nX \000\000\006\n\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]0`\000\000\014\034\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:b\000\000\000\030@\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006uE\000\000\0001\020\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rk\014\000\000\000b`\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033V\034\000\000\001F\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007,@\000\000\003\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000nY\020\000\000\006\036\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]2@\000\000\014D\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:e@\000\000\031\n\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006uL\000\000\00020\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rk\032\000\000\000dh\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033V8\000\000\001J@\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007,x\000\000\003\025 \000\000\000\000\000\000\000\000\000\000\000\000\000@\000nZ\000\000\000\006.\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001]4 \000\000\014]\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003:i\000\000\000\031H\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006uS\000\000\0003\024\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rk(\000\000\000f`\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033VT\000\000\001N@\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007-0\000\000\003\035 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000nZp\000\000\006>\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001_\026`\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003L?@\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006|]\000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\rXB\000\000,\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033xL\000\000X\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0009HR\000\0011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000s\021 \000\002b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001_E\000\000\005D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003?\n@\000\013\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\007\031\005`\000\026\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\r|.\000\000,0\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033x`\000\000X`\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007qP\000\0012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000oc0\000\002e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001f\037`\000\005\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003?\016\000\000\n|\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006~\035\000\000\025x\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\r|>\000\000-P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033y\000\000\000[ \000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0009G\030\000\0016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000s\016@\000\002[\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001f\034@\000\005\\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003L<@\000\013,\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006~\"\000\000\025H\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\r|F\000\000+\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033y\024\000\000V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007r0\000\001,\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000oe\000\000\002^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001_J@\000\005$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003?\026@\000\n\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006l\r\000\000\0258\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\r|^\000\000,p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033y@\000\000Y@\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0009H\002\000\001+\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000of\020\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001[W \000\005*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\0037/@\000\nT\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006~2\000\000\025 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\0162\006@\000+P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033/P\000\000W \000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007s\030\000\001)@\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000s\016\\\000\002S\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001_M\000\000\005T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003L:@\000\013(\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006~5\000\000\025`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\r|l\000\000+@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\033y`\000\000T \000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007sH\000\0014@\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000og0\000\002P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001_O \000\005\034\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\003?\037\000\000\n4\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\006~?\000\000\024`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\r}\002\000\000)0\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\034cp\000\000R@\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \0007t\030\000\001$@\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000ohP\000\002F\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001_Q@\000\005\014\000\000\000\000\000\000\000\006~Y\000\0007uX\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016*\022\000\000rT0\000\007\025=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\034\001P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000Laj^4$4s\033;n`\000\n\000\005@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000r[\000\000\007\025X\000\0009-P\000\003Jm\000\000\034Vp\000\001e7\000\000\016+<\000\000r[`\000\007\025`\000\0009.\000\000\003Jq\000\000\034W\010\000\001e9\000\000\016+H\000\000r\\`\000\007\025f\000\0009.@\000\003Jt\000\000\034W(\000\001e:@\000\016+X\000\000r]@\000\007\025n\000\0009.p\000\003Jx\000\000\034W@\000\001e<@\000\016+d\000\000r^@\000\007\025t\000\0009/0\000\003J{\000\000\034W`\000\001e>\000\000\016+t\000\000r_ \000\007\025|\000\0009/`\000\003J\177\000\000\034Wx\000\001e@\000\000\016,\000\000\000r` \000\007\026\002\000\00090 \000\003K\002\000\000\034X\030\000\001eA@\000\016,\020\000\000ra\000\000\007\026\n\000\00090P\000\003K\006\000\000\034X0\000\001eC@\000\016,\034\000\000rb\000\000\007\026\020\000\00091\020\000\003K\011\000\000\034XP\000\001eE\000\000\016,,\000\000rb`\000\007\026\030\000\00091@\000\003K\r\000\000\034Xh\000\001eG\000\000\016,8\000\000rc`\000\007\026\036\000\00092\000\000\003K\020\000\000\034Y\010\000\001eH@\000\016,H\000\000rd@\000\007\026&\000\000920\000\003K\024\000\000\034Y \000\001eJ@\000\016,T\000\000re@\000\007\026,\000\00092p\000\003K\027\000\000\034Y@\000\001eL\000\000\016,d\000\000rf \000\007\0264\000\00093 \000\003K\033\000\000\034YX\000\001eN\000\000\016,p\000\000rg \000\007\026:\000\00093`\000\003K\036\000\000\034Yx\000\001eO@\000\016-\000\000\000rh\000\000\007\026B\000\00094\020\000\003K\"\000\000\034Z\020\000\001eQ@\000\016-\014\000\000ri\000\000\007\026H\000\00094P\000\003K%\000\000\034Z0\000\001eS\000\000\016-\034\000\000ri`\000\007\026P\000\00095\000\000\003K)\000\000\034ZH\000\001eU\000\000\016-(\000\000rj`\000\007\026V\000\00095@\000\003K,\000\000\034Zh\000\001eV@\000\016-8\000\000rk@\000\007\026^\000\00095p\000\003K0\000\000\034[\000\000\001eX@\000\016-D\000\000rl@\000\007\026d\000\000960\000\003K3\000\000\034[ \000\001eZ\000\000\016-T\000\000rm \000\007\026l\000\00096`\000\003K7\000\000\034[8\000\001e\\\000\000\016-`\000\000rn \000\007\026r\000\00097 \000\003K:\000\000\034[X\000\001e]@\000\016-p\000\000ro\000\000\007\026z\000\00097P\000\003K>\000\000\034[p\000\001e_@\000\016-|\000\000rp\000\000\007\027\000\000\00098\020\000\003KA\000\000\034\\\020\000\001ea\000\000\016.\014\000\000rp`\000\007\027\010\000\00098@\000\003KE\000\000\034\\(\000\001ec\000\000\016.\030\000\000rq`\000\007\027\016\000\00099\000\000\003KH\000\000\034\\H\000\001ed@\000\016.(\000\000rr@\000\007\027\026\000\000990\000\003KL\000\000\034\\`\000\001ef@\000\016.4\000\000rs@\000\007\027\034\000\00099p\000\003KO\000\000\034]\000\000\001eh\000\000\016.D\000\000rt \000\007\027$\000\0009: \000\003KS\000\000\034]\030\000\001ej\000\000\016.P\000\000ru \000\007\027*\000\0009:`\000\003KV\000\000\034]8\000\001ek@\000\016.`\000\000rv\000\000\007\0272\000\0009;\020\000\003KZ\000\000\034]P\000\001em@\000\016.l\000\000rw\000\000\007\0278\000\0009;P\000\003K]\000\000\034]p\000\001eo\000\000\016.|\000\000rw`\000\007\027@\000\0009<\000\000\003Ka\000\000\034^\010\000\001eq\000\000\016/\010\000\000rx`\000\007\027F\000\0009<@\000\003Kd\000\000\034^(\000\001er@\000\016/\030\000\000ry@\000\007\027N\000\0009<p\000\003Kh\000\000\034^@\000\001et@\000\016/$\000\000rz@\000\007\027T\000\0009=0\000\003Kk\004\nM\006I$@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 Th4J$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\\R\000\000m\000`\000\006h\006\000\0006@0\000\0034\003\000\000\033 \030\000\001Z\001@\000\rP\014\000\000m\000`\000\006h\006\017w{}~\177?_ow{}~\177?_`\000\000\000\000\000\032?\177\177^8\000\000\001r`\000\000\000\002\000\000\000\000\000\000\000\0005\177\177\177<p\000\000\003e@\000\000\000\004\000\000\000\000\000\020\010\004\002\001",0x6b0);
+    private static final int[] _data5 = decodeData("\000\000\000\000\000\000\000\000 \000\000\000\002\000\000\000\000@\037\177\177\177~w1\000\000\0078\000\000\000\000\000\000\000@\000\000\000\004\000\000\000\000(@\000\000\000\000\000\000\000\022 \000\000\000\000\000\000\000\010\020\000\000\000\000\000\000\000\003H\000\000\000\000\000\000\000\001D\000\000\000\000\000\000\000\000R\000\000\000\000\000\000\000\000!\000\000\000\000\000\000\000\000\014@\000\000\000\000\000\000\000\004 \000\000\000\000\000\000\000\014\017\000\000\000\000\000\000\000\011\007 \000\000\000\000\000\000\003#@\000\000\000\000\000\000\002aP\000\000\000\000\000\000\001(h\000\000\000\000\000\000\000P4\000\000\000\000\000\000\000&\032\000\000\000\000\000\000\000\033\014\000\000\000\000\000\000\000\r\006\000\000\000\000\000\000\000\006\"`\000\000\000\000\000\000\003\0010\000\000\000\000\000\000\0018X\000\000\000\000\000\000\000@(\000\000\000\000\000\000\000\036\024\000\000\000\000\000\000\000\016\n\000\000\000\000\000\000\000\020\004@\000\000\000\000\000\000\007b \000\000\000\000\000\000\003a\020\000\000\000\000\000\000\001hH\000\000\000\000\000\000\001\004 \000\000\000\000\000\000\0008\016\000\000\000\000\000\000\000\"\006\000\000\000\000\000\000\000\022B@\000\000\000\000\000\000\011\001 \000\000\000\000\000\000\0040@\000\000\000\000\000\000\000X\030\000\000\000\000\000\000\000D\010\000\000\000\000\000\000\000\002\002\000\000\000\006\013IFt0[@\000\003\005dc1[n0\000\001Br1\\m\026p\000\000\000\000\000\000\013\177@\000\000\000\000\000\000\001\177`\000\000\000\000\000\000\001\000$\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000 \033|\000\000\000\000\000\0000\014\000\000\000\000\000\000\000\000\000\014 \000\000\000b@\000\000\006\014\000\000\0000@\000\000\016<x\000\000\000\000(\000\000\000\000 \000\000\000\002s1\\@\007\023\005n\0008\031.@\003Mjb=\033mf(\0014o7\031 \000\000\000\000s1\\O\006{H\000\0006\034n \003\025dr7\\@\000\000\001Jo9\000\0146\0234\000b9\033\000\006\023IB\0000\\n \003\005fl\000\030-f \000l5\034\014&`\000\000\000\000\003Ex\007\023\010\000\000\000\000\000\000!@p\000\000\000\000r9\020\177y\020~jD!41?|H?5\"\020Z\030?\r|Cd \000uN\017~\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\003\177`\000\000\000\000\000\000\005\177`\000\000\000\000\000\000\000\177\020VN\\2\026h\"?T^i2#X\033k\037l!V5\003 =(Ovt.7\nL\020\033G|\022$I\022\000 \177s~U*U*U*Pm~E4\"\013\r&a<\177-o\013*-wv4?Yl\036*{R4m\037o\016\0347xF\0268Oy\031Lf3\030uq\007\177\000\000\000\000\000\000\000\003\177@\000\000\000\000\000\000\001\177`\000\000\000\000\000\000\003\177p\000\000\000\000\000\000\000Gw\177\177~\000\000\000\000\037x\000\000\000\000\000\000\0001}\177\177\177@\000\000\000\017\177\000\000\000\000\000\000\000\004\000$C{*\021\005QA\177r!}U\010Bh`~\002\036x!_o\\\022?${|\007(\006e\010\037i\020\"EUQ\017\035Oy\034\nT\035\010\"\025'}&X$\003u[oS~\025*U*U*U)~g8bl%i\024\010\177f\003\033\0038h\0052@\000\n\\Ybf\025H \000g\"8r\024-%O~\000\000\000\000\000\000\000\007I\r\030L3\n\027\000s\177\000\000\000\000\000\000\000\001\177r!}U\010Bh`y\021S\011F1\"p\016~\033y\007H@\001k\034\037|\000\000\000\000\000\000\000\017`#o\004\033}{B'tO?@u\000lQ\003}\022\004(ZZ\021sY\177\023A*CQ\004\"T\177Tk\004@>[=z?bU*U*U*U\037lw\014-D]\022A\017|`307\r\000V(\000\001+K\034,bY\004\000\014t'\016\"ETY\177@\000\000\000\000\000\000\000\177i\020~jD!40?x\000\000\000\000\000\000\000_|\000\000\000\000\000\000\000\037F~!r\020\000:g\007\1778U\016`\000\000\000\003rR\\\013|\027;t!\177 \000\000\000\000\000\000\000\177U*U*U*U*?p\000\000\000\000\000\000\000\037}bT;\024W\002\177\020h\000\000\000\000\000\000\000\007|SxPJ\"S]s~6\014JIr;6)\177\"t0*#T\010\004\177U*U*\030y\031\032?m[6m[>W\177\037xf3\031Lf3\001P\001\000\000\000\000\000\000\000\007~v\034\023`\000\000\000\013qx_`\n\026`\037)\177]G\004w\007 \037ty\027\nQlR\\\013|\001R[C|\027cfY\037yEd\030\000\000\000\000\017|br\013}z\034{wb\002qB\014T\033\007\023s\030ni9/TM\001zw= q:&_D~\021+\032Ur.xX?30-A5z{\023\037q*U*U*U\037\020\000\000\000\000\000\000\000\000\007\177I\007vT \000\000\003nBha\r\030L3\011w!40FL\000\000\000w#\014bE`\033Af?r\027f\006n'\021\003\037x\000\000\000\000\000\000\000\016t1L(\\\000\000\000\007\027\\\0164%\020\0228\024\013@\000\000\000\000\000\000\001\177N\000\000\000\000\000\000\000\177R\000\000\000\000\000\000\000?x\000\000\000\000\000\000\000^j\037.Mz\0208j\017D\036tz{4Xq\007i\023y\037\000N\024USwh\003 \014rbY\001}-A6\005X\025\013\\\177%*U*U*U\030?p\000\000\000\000\000\000\000\037\034\000\000\000\000\000\000\000\020.\000\000\000\000\000\000\000\007|\000\000\000\000\000\000\000\004\001\000\000\000\000\000\000\000\001\177@\000\000\000\000\000\000\000\177p\000\000\000\000\000\000\000=rv'%V?*|\037\026\\^4(W\034uOXqo\r/1\177\037'rP\006@\031`X:S|\004\"\021\010D\037\n1\177\nU*U*U*$\177`\000\000\000\000\000\000\000?x\000\000\000\000\000\000\000_|\000\000\000\000\000\000\000\017}\022\017m(D\026F\007H\r\030L3\n\027\000{wMkKmX\n7\031|(~D(\006y\025\030~C\"6\036/\023\024\002?6[$,JX\006(\037eLO$\020\rV\033Ox\021\010D\"\020\177\036GoY)`t_^ZCxJp\017\031<\024~I|`&{FQQ\003 ~Wmr\037n\004\014*?A\011\\>K:\011\023\037jt\033PnfA\177\017zU*U*U*Xoc?\020y\010\000\0353@\000\000\000\001\000\000\000\000\002\r \000\000\000\000\000\000\000\003%7\007x/GM2~\033y\007H@\001k\034\036$\000\000\000\000\000\000\000\000\000sBP\000\007\023N\000\0009\034q\177\177\177\177p\000\010\000\000\000\001`pZ\007`\000\000\000\000\000\000\000\177x\000\000\000\000\000\000\000?i!tv\033=\006a\037qQ\"D-AHYOz4 M!\037<~g\177\000\000\000\000\000\000\000\004\001\020\000\000\000\000\000\000\002\0008\000\000\000\000\000\000\001\000\024\000\000\000\000\000\000\000?p\000\000\000\000\000\000\000\000\000\000\000\010\000\000\000\000\017~\000\000\000\000\000\000\000\010\002 \000\000\000\000\000\000\000\000\031H\000?p\000\000\005\177@\000\000\000\000\000\000\000\177`\000\000\000\000\000\000\000?x\000\000\000\000\000\000\000 |\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\027\177\000\000\000\000\000\000\000\004\016\177\177\177\177p\000\000\002\007@\000\000\000\000\000\000\000\177_\177\177rJ\001V*?p\000\000\003-?J5\037s\177\177|R@5J@\000jp\000\002\001",0x1df);
+
+
+    private final void trampoline() throws ExecutionException {
+        while(state == RUNNING) {
+            switch(pc>>>9) {
+                case 0x80: run_10000(); break; 
+                case 0x81: run_10200(); break; 
+                case 0x82: run_10400(); break; 
+                case 0x83: run_10600(); break; 
+                case 0x84: run_10800(); break; 
+                case 0x85: run_10a00(); break; 
+                case 0x86: run_10c00(); break; 
+                case 0x87: run_10e00(); break; 
+                case 0x88: run_11000(); break; 
+                case 0x89: run_11200(); break; 
+                case 0x8a: run_11400(); break; 
+                case 0x8b: run_11600(); break; 
+                case 0x8c: run_11800(); break; 
+                case 0x8d: run_11a00(); break; 
+                case 0x8e: run_11c00(); break; 
+                case 0x8f: run_11e00(); break; 
+                case 0x90: run_12000(); break; 
+                case 0x91: run_12200(); break; 
+                case 0x92: run_12400(); break; 
+                case 0x93: run_12600(); break; 
+                case 0x94: run_12800(); break; 
+                case 0x95: run_12a00(); break; 
+                case 0x96: run_12c00(); break; 
+                case 0x97: run_12e00(); break; 
+                case 0x98: run_13000(); break; 
+                case 0x99: run_13200(); break; 
+                case 0x9a: run_13400(); break; 
+                case 0x9b: run_13600(); break; 
+                case 0x9c: run_13800(); break; 
+                case 0x9d: run_13a00(); break; 
+                case 0x9e: run_13c00(); break; 
+                case 0x9f: run_13e00(); break; 
+                case 0xa0: run_14000(); break; 
+                case 0xa1: run_14200(); break; 
+                case 0xa2: run_14400(); break; 
+                case 0xa3: run_14600(); break; 
+                case 0xa4: run_14800(); break; 
+                case 0xa5: run_14a00(); break; 
+                case 0xa6: run_14c00(); break; 
+                case 0xa7: run_14e00(); break; 
+                case 0xa8: run_15000(); break; 
+                case 0xa9: run_15200(); break; 
+                case 0xaa: run_15400(); break; 
+                case 0xab: run_15600(); break; 
+                case 0xac: run_15800(); break; 
+                case 0xad: run_15a00(); break; 
+                case 0xae: run_15c00(); break; 
+                case 0xaf: run_15e00(); break; 
+                case 0xb0: run_16000(); break; 
+                case 0xb1: run_16200(); break; 
+                case 0xb2: run_16400(); break; 
+                case 0xb3: run_16600(); break; 
+                case 0xb4: run_16800(); break; 
+                case 0xb5: run_16a00(); break; 
+                case 0xb6: run_16c00(); break; 
+                case 0xb7: run_16e00(); break; 
+                case 0xb8: run_17000(); break; 
+                case 0xb9: run_17200(); break; 
+                case 0xba: run_17400(); break; 
+                case 0xbb: run_17600(); break; 
+                case 0xbc: run_17800(); break; 
+                case 0xbd: run_17a00(); break; 
+                case 0xbe: run_17c00(); break; 
+                case 0xbf: run_17e00(); break; 
+                case 0xc0: run_18000(); break; 
+                case 0xc1: run_18200(); break; 
+                case 0xc2: run_18400(); break; 
+                case 0xc3: run_18600(); break; 
+                case 0xc4: run_18800(); break; 
+                case 0xc5: run_18a00(); break; 
+                case 0xc6: run_18c00(); break; 
+                case 0xc7: run_18e00(); break; 
+                case 0xc8: run_19000(); break; 
+                case 0xc9: run_19200(); break; 
+                case 0xca: run_19400(); break; 
+                case 0xcb: run_19600(); break; 
+                case 0xcc: run_19800(); break; 
+                case 0xcd: run_19a00(); break; 
+                case 0xce: run_19c00(); break; 
+                case 0xcf: run_19e00(); break; 
+                case 0xd0: run_1a000(); break; 
+                case 0xd1: run_1a200(); break; 
+                case 0xd2: run_1a400(); break; 
+                case 0xd3: run_1a600(); break; 
+                case 0xd4: run_1a800(); break; 
+                case 0xd5: run_1aa00(); break; 
+                case 0xd6: run_1ac00(); break; 
+                case 0xd7: run_1ae00(); break; 
+                case 0xd8: run_1b000(); break; 
+                case 0xd9: run_1b200(); break; 
+                case 0xda: run_1b400(); break; 
+                case 0xdb: run_1b600(); break; 
+                case 0xdc: run_1b800(); break; 
+                case 0xdd: run_1ba00(); break; 
+                case 0xde: run_1bc00(); break; 
+                case 0xdf: run_1be00(); break; 
+                case 0xe0: run_1c000(); break; 
+                case 0xe1: run_1c200(); break; 
+                case 0xe2: run_1c400(); break; 
+                case 0xe3: run_1c600(); break; 
+                case 0xe4: run_1c800(); break; 
+                case 0xe5: run_1ca00(); break; 
+                case 0xe6: run_1cc00(); break; 
+                case 0xe7: run_1ce00(); break; 
+                case 0xe8: run_1d000(); break; 
+                case 0xe9: run_1d200(); break; 
+                case 0xea: run_1d400(); break; 
+                case 0xeb: run_1d600(); break; 
+                case 0xec: run_1d800(); break; 
+                case 0xed: run_1da00(); break; 
+                case 0xee: run_1dc00(); break; 
+                case 0xef: run_1de00(); break; 
+                case 0xf0: run_1e000(); break; 
+                case 0xf1: run_1e200(); break; 
+                case 0xf2: run_1e400(); break; 
+                case 0xf3: run_1e600(); break; 
+                case 0xf4: run_1e800(); break; 
+                case 0xf5: run_1ea00(); break; 
+                case 0xf6: run_1ec00(); break; 
+                case 0xf7: run_1ee00(); break; 
+                case 0xf8: run_1f000(); break; 
+                case 0xf9: run_1f200(); break; 
+                case 0xfa: run_1f400(); break; 
+                case 0xfb: run_1f600(); break; 
+                case 0xfc: run_1f800(); break; 
+                case 0xfd: run_1fa00(); break; 
+                case 0xfe: run_1fc00(); break; 
+                case 0xff: run_1fe00(); break; 
+                case 0x100: run_20000(); break; 
+                case 0x101: run_20200(); break; 
+                case 0x102: run_20400(); break; 
+                case 0x103: run_20600(); break; 
+                case 0x104: run_20800(); break; 
+                case 0x105: run_20a00(); break; 
+                case 0x106: run_20c00(); break; 
+                case 0x107: run_20e00(); break; 
+                case 0x108: run_21000(); break; 
+                case 0x109: run_21200(); break; 
+                case 0x10a: run_21400(); break; 
+                case 0x10b: run_21600(); break; 
+                case 0x10c: run_21800(); break; 
+                case 0x10d: run_21a00(); break; 
+                case 0x10e: run_21c00(); break; 
+                case 0x10f: run_21e00(); break; 
+                case 0x110: run_22000(); break; 
+                case 0x111: run_22200(); break; 
+                case 0x112: run_22400(); break; 
+                case 0x113: run_22600(); break; 
+                case 0x114: run_22800(); break; 
+                case 0x115: run_22a00(); break; 
+                case 0x116: run_22c00(); break; 
+                case 0x117: run_22e00(); break; 
+                case 0x118: run_23000(); break; 
+                case 0x119: run_23200(); break; 
+                case 0x11a: run_23400(); break; 
+                case 0x11b: run_23600(); break; 
+                case 0x11c: run_23800(); break; 
+                case 0x11d: run_23a00(); break; 
+                case 0x11e: run_23c00(); break; 
+                case 0x11f: run_23e00(); break; 
+                case 0x120: run_24000(); break; 
+                case 0x121: run_24200(); break; 
+                case 0x122: run_24400(); break; 
+                case 0x123: run_24600(); break; 
+                case 0x124: run_24800(); break; 
+                case 0x125: run_24a00(); break; 
+                case 0x126: run_24c00(); break; 
+                case 0x127: run_24e00(); break; 
+                case 0x128: run_25000(); break; 
+                case 0x129: run_25200(); break; 
+                case 0x12a: run_25400(); break; 
+                case 0x12b: run_25600(); break; 
+                case 0x12c: run_25800(); break; 
+                case 0x12d: run_25a00(); break; 
+                case 0x12e: run_25c00(); break; 
+                case 0x12f: run_25e00(); break; 
+                case 0x130: run_26000(); break; 
+                case 0x131: run_26200(); break; 
+                case 0x132: run_26400(); break; 
+                case 0x133: run_26600(); break; 
+                case 0x134: run_26800(); break; 
+                case 0x135: run_26a00(); break; 
+                case 0x136: run_26c00(); break; 
+                case 0x137: run_26e00(); break; 
+                case 0x138: run_27000(); break; 
+                case 0x139: run_27200(); break; 
+                case 0x13a: run_27400(); break; 
+                case 0x13b: run_27600(); break; 
+                case 0x13c: run_27800(); break; 
+                case 0x13d: run_27a00(); break; 
+                case 0x13e: run_27c00(); break; 
+                case 0x13f: run_27e00(); break; 
+                case 0x140: run_28000(); break; 
+                case 0x141: run_28200(); break; 
+                case 0x142: run_28400(); break; 
+                case 0x143: run_28600(); break; 
+                case 0x144: run_28800(); break; 
+                case 0x145: run_28a00(); break; 
+                case 0x146: run_28c00(); break; 
+                case 0x147: run_28e00(); break; 
+                case 0x148: run_29000(); break; 
+                case 0x149: run_29200(); break; 
+                case 0x14a: run_29400(); break; 
+                case 0x14b: run_29600(); break; 
+                case 0x14c: run_29800(); break; 
+                case 0x14d: run_29a00(); break; 
+                case 0x14e: run_29c00(); break; 
+                case 0x14f: run_29e00(); break; 
+                case 0x150: run_2a000(); break; 
+                case 0x151: run_2a200(); break; 
+                case 0x152: run_2a400(); break; 
+                case 0x153: run_2a600(); break; 
+                case 0x154: run_2a800(); break; 
+                case 0x155: run_2aa00(); break; 
+                case 0x156: run_2ac00(); break; 
+                case 0x157: run_2ae00(); break; 
+                case 0x158: run_2b000(); break; 
+                case 0x159: run_2b200(); break; 
+                case 0x15a: run_2b400(); break; 
+                case 0x15b: run_2b600(); break; 
+                case 0x15c: run_2b800(); break; 
+                case 0x15d: run_2ba00(); break; 
+                case 0x15e: run_2bc00(); break; 
+                case 0x15f: run_2be00(); break; 
+                case 0x160: run_2c000(); break; 
+                case 0x161: run_2c200(); break; 
+                case 0x162: run_2c400(); break; 
+                case 0x163: run_2c600(); break; 
+                case 0x164: run_2c800(); break; 
+                case 0x165: run_2ca00(); break; 
+                case 0x166: run_2cc00(); break; 
+                case 0x167: run_2ce00(); break; 
+                case 0x168: run_2d000(); break; 
+                case 0x169: run_2d200(); break; 
+                case 0x16a: run_2d400(); break; 
+                case 0x16b: run_2d600(); break; 
+                case 0x16c: run_2d800(); break; 
+                case 0x16d: run_2da00(); break; 
+                case 0x16e: run_2dc00(); break; 
+                case 0x16f: run_2de00(); break; 
+                case 0x170: run_2e000(); break; 
+                case 0x171: run_2e200(); break; 
+                case 0x172: run_2e400(); break; 
+                case 0x173: run_2e600(); break; 
+                case 0x174: run_2e800(); break; 
+                case 0x175: run_2ea00(); break; 
+                case 0x176: run_2ec00(); break; 
+                case 0x177: run_2ee00(); break; 
+                case 0x178: run_2f000(); break; 
+                case 0x179: run_2f200(); break; 
+                case 0x17a: run_2f400(); break; 
+                case 0x17b: run_2f600(); break; 
+                case 0x17c: run_2f800(); break; 
+                case 0x17d: run_2fa00(); break; 
+                case 0x17e: run_2fc00(); break; 
+                case 0x17f: run_2fe00(); break; 
+                case 0x180: run_30000(); break; 
+                case 0x181: run_30200(); break; 
+                case 0x182: run_30400(); break; 
+                case 0x183: run_30600(); break; 
+                case 0x184: run_30800(); break; 
+                case 0x185: run_30a00(); break; 
+                case 0x186: run_30c00(); break; 
+                case 0x187: run_30e00(); break; 
+                case 0x188: run_31000(); break; 
+                case 0x189: run_31200(); break; 
+                case 0x18a: run_31400(); break; 
+                case 0x18b: run_31600(); break; 
+                case 0x18c: run_31800(); break; 
+                case 0x18d: run_31a00(); break; 
+                case 0x18e: run_31c00(); break; 
+                case 0x18f: run_31e00(); break; 
+                case 0x190: run_32000(); break; 
+                case 0x191: run_32200(); break; 
+                case 0x192: run_32400(); break; 
+                case 0x193: run_32600(); break; 
+                case 0x194: run_32800(); break; 
+                case 0x195: run_32a00(); break; 
+                case 0x196: run_32c00(); break; 
+                case 0x197: run_32e00(); break; 
+                case 0x198: run_33000(); break; 
+                case 0x199: run_33200(); break; 
+                case 0x19a: run_33400(); break; 
+                case 0x19b: run_33600(); break; 
+                case 0x19c: run_33800(); break; 
+                case 0x19d: run_33a00(); break; 
+                case 0x19e: run_33c00(); break; 
+                case 0x19f: run_33e00(); break; 
+                case 0x1a0: run_34000(); break; 
+                case 0x1a1: run_34200(); break; 
+                case 0x1a2: run_34400(); break; 
+                case 0x1a3: run_34600(); break; 
+                case 0x1a4: run_34800(); break; 
+                case 0x1a5: run_34a00(); break; 
+                case 0x1a6: run_34c00(); break; 
+                case 0x1a7: run_34e00(); break; 
+                case 0x1a8: run_35000(); break; 
+                case 0x1a9: run_35200(); break; 
+                case 0x1aa: run_35400(); break; 
+                case 0x1ab: run_35600(); break; 
+                case 0x1ac: run_35800(); break; 
+                case 0x1ad: run_35a00(); break; 
+                case 0x1ae: run_35c00(); break; 
+                case 0x1af: run_35e00(); break; 
+                case 0x1b0: run_36000(); break; 
+                case 0x1b1: run_36200(); break; 
+                case 0x1b2: run_36400(); break; 
+                case 0x1b3: run_36600(); break; 
+                case 0x1b4: run_36800(); break; 
+                case 0x1b5: run_36a00(); break; 
+                case 0x1b6: run_36c00(); break; 
+                case 0x1b7: run_36e00(); break; 
+                case 0x1b8: run_37000(); break; 
+                case 0x1b9: run_37200(); break; 
+                case 0x1ba: run_37400(); break; 
+                case 0x1bb: run_37600(); break; 
+                case 0x1bc: run_37800(); break; 
+                case 0x1bd: run_37a00(); break; 
+                case 0x1be: run_37c00(); break; 
+                case 0x1bf: run_37e00(); break; 
+                case 0x1c0: run_38000(); break; 
+                case 0x1c1: run_38200(); break; 
+                case 0x1c2: run_38400(); break; 
+                case 0x1c3: run_38600(); break; 
+                case 0x1c4: run_38800(); break; 
+                case 0x1c5: run_38a00(); break; 
+                case 0x1c6: run_38c00(); break; 
+                case 0x1c7: run_38e00(); break; 
+                case 0x1c8: run_39000(); break; 
+                case 0x1c9: run_39200(); break; 
+                case 0x1ca: run_39400(); break; 
+                case 0x1cb: run_39600(); break; 
+                case 0x1cc: run_39800(); break; 
+                case 0x1cd: run_39a00(); break; 
+                case 0x1ce: run_39c00(); break; 
+                case 0x1cf: run_39e00(); break; 
+                case 0x1d0: run_3a000(); break; 
+                case 0x1d1: run_3a200(); break; 
+                case 0x1d2: run_3a400(); break; 
+                case 0x1d3: run_3a600(); break; 
+                case 0x1d4: run_3a800(); break; 
+                case 0x1d5: run_3aa00(); break; 
+                case 0x1d6: run_3ac00(); break; 
+                case 0x1d7: run_3ae00(); break; 
+                case 0x1d8: run_3b000(); break; 
+                case 0x1d9: run_3b200(); break; 
+                case 0x1da: run_3b400(); break; 
+                case 0x1db: run_3b600(); break; 
+                case 0x1dc: run_3b800(); break; 
+                case 0x1dd: run_3ba00(); break; 
+                case 0x1de: run_3bc00(); break; 
+                case 0x1df: run_3be00(); break; 
+                case 0x1e0: run_3c000(); break; 
+                case 0x1e1: run_3c200(); break; 
+                case 0x1e2: run_3c400(); break; 
+                case 0x1e3: run_3c600(); break; 
+                case 0x1e4: run_3c800(); break; 
+                case 0x1e5: run_3ca00(); break; 
+                case 0x1e6: run_3cc00(); break; 
+                case 0x1e7: run_3ce00(); break; 
+                case 0x1e8: run_3d000(); break; 
+                case 0x1e9: run_3d200(); break; 
+                case 0x1ea: run_3d400(); break; 
+                case 0x1eb: run_3d600(); break; 
+                case 0x1ec: run_3d800(); break; 
+                case 0x1ed: run_3da00(); break; 
+                case 0x1ee: run_3dc00(); break; 
+                case 0x1ef: run_3de00(); break; 
+                case 0x1f0: run_3e000(); break; 
+                case 0x1f1: run_3e200(); break; 
+                case 0x1f2: run_3e400(); break; 
+                case 0x1f3: run_3e600(); break; 
+                case 0x1f4: run_3e800(); break; 
+                case 0x1f5: run_3ea00(); break; 
+                case 0x1f6: run_3ec00(); break; 
+                case 0x1f7: run_3ee00(); break; 
+                case 0x1f8: run_3f000(); break; 
+                case 0x1f9: run_3f200(); break; 
+                case 0x1fa: run_3f400(); break; 
+                case 0x1fb: run_3f600(); break; 
+                case 0x1fc: run_3f800(); break; 
+                case 0x1fd: run_3fa00(); break; 
+                case 0x1fe: run_3fc00(); break; 
+                case 0x1ff: run_3fe00(); break; 
+                case 0x200: run_40000(); break; 
+                case 0x201: run_40200(); break; 
+                case 0x202: run_40400(); break; 
+                case 0x203: run_40600(); break; 
+                case 0x204: run_40800(); break; 
+                case 0x205: run_40a00(); break; 
+                case 0x206: run_40c00(); break; 
+                case 0x207: run_40e00(); break; 
+                case 0x208: run_41000(); break; 
+                case 0x209: run_41200(); break; 
+                case 0x20a: run_41400(); break; 
+                case 0x20b: run_41600(); break; 
+                case 0x20c: run_41800(); break; 
+                case 0x20d: run_41a00(); break; 
+                case 0x20e: run_41c00(); break; 
+                case 0x20f: run_41e00(); break; 
+                case 0x210: run_42000(); break; 
+                case 0x211: run_42200(); break; 
+                case 0x212: run_42400(); break; 
+                case 0x213: run_42600(); break; 
+                case 0x214: run_42800(); break; 
+                case 0x215: run_42a00(); break; 
+                case 0x216: run_42c00(); break; 
+                case 0x217: run_42e00(); break; 
+                case 0x218: run_43000(); break; 
+                case 0x219: run_43200(); break; 
+                case 0x21a: run_43400(); break; 
+                case 0x21b: run_43600(); break; 
+                case 0x21c: run_43800(); break; 
+                case 0x21d: run_43a00(); break; 
+                case 0x21e: run_43c00(); break; 
+                case 0x21f: run_43e00(); break; 
+                case 0x220: run_44000(); break; 
+                case 0x221: run_44200(); break; 
+                case 0x222: run_44400(); break; 
+                case 0x223: run_44600(); break; 
+                case 0x224: run_44800(); break; 
+                case 0x225: run_44a00(); break; 
+                case 0x226: run_44c00(); break; 
+                case 0x227: run_44e00(); break; 
+                case 0x228: run_45000(); break; 
+                case 0x229: run_45200(); break; 
+                case 0x22a: run_45400(); break; 
+                case 0x22b: run_45600(); break; 
+                case 0x22c: run_45800(); break; 
+                case 0x22d: run_45a00(); break; 
+                case 0x22e: run_45c00(); break; 
+                case 0x22f: run_45e00(); break; 
+                case 0x230: run_46000(); break; 
+                case 0x231: run_46200(); break; 
+                case 0x232: run_46400(); break; 
+                case 0x233: run_46600(); break; 
+                case 0x234: run_46800(); break; 
+                case 0x235: run_46a00(); break; 
+                case 0x236: run_46c00(); break; 
+                case 0x237: run_46e00(); break; 
+                case 0x238: run_47000(); break; 
+                case 0x239: run_47200(); break; 
+                case 0x23a: run_47400(); break; 
+                case 0x23b: run_47600(); break; 
+                case 0x23c: run_47800(); break; 
+                case 0x23d: run_47a00(); break; 
+                case 0x23e: run_47c00(); break; 
+                case 0x23f: run_47e00(); break; 
+                case 0x240: run_48000(); break; 
+                case 0x241: run_48200(); break; 
+                case 0x242: run_48400(); break; 
+                case 0x243: run_48600(); break; 
+                case 0x244: run_48800(); break; 
+                case 0x245: run_48a00(); break; 
+                case 0x246: run_48c00(); break; 
+                case 0x247: run_48e00(); break; 
+                case 0x248: run_49000(); break; 
+                case 0x249: run_49200(); break; 
+                case 0x24a: run_49400(); break; 
+                case 0x24b: run_49600(); break; 
+                case 0x24c: run_49800(); break; 
+                case 0x24d: run_49a00(); break; 
+                case 0x24e: run_49c00(); break; 
+                case 0x24f: run_49e00(); break; 
+                case 0x250: run_4a000(); break; 
+                case 0x251: run_4a200(); break; 
+                case 0x252: run_4a400(); break; 
+                case 0x253: run_4a600(); break; 
+                case 0x254: run_4a800(); break; 
+                case 0x255: run_4aa00(); break; 
+                case 0x256: run_4ac00(); break; 
+                case 0x257: run_4ae00(); break; 
+                case 0x258: run_4b000(); break; 
+                case 0x259: run_4b200(); break; 
+                case 0x25a: run_4b400(); break; 
+                case 0x25b: run_4b600(); break; 
+                case 0x25c: run_4b800(); break; 
+                case 0x25d: run_4ba00(); break; 
+                case 0x25e: run_4bc00(); break; 
+                case 0x25f: run_4be00(); break; 
+                case 0x260: run_4c000(); break; 
+                case 0x261: run_4c200(); break; 
+                case 0x262: run_4c400(); break; 
+                case 0x263: run_4c600(); break; 
+                case 0x264: run_4c800(); break; 
+                case 0x265: run_4ca00(); break; 
+                case 0x266: run_4cc00(); break; 
+                case 0x267: run_4ce00(); break; 
+                case 0x268: run_4d000(); break; 
+                case 0x269: run_4d200(); break; 
+                case 0x26a: run_4d400(); break; 
+                case 0x26b: run_4d600(); break; 
+                case 0x26c: run_4d800(); break; 
+                case 0x26d: run_4da00(); break; 
+                case 0x26e: run_4dc00(); break; 
+                case 0x26f: run_4de00(); break; 
+                case 0x270: run_4e000(); break; 
+                case 0x271: run_4e200(); break; 
+                case 0x272: run_4e400(); break; 
+                case 0x273: run_4e600(); break; 
+                case 0x274: run_4e800(); break; 
+                case 0x275: run_4ea00(); break; 
+                case 0x276: run_4ec00(); break; 
+                case 0x277: run_4ee00(); break; 
+                case 0x278: run_4f000(); break; 
+                case 0x279: run_4f200(); break; 
+                case 0x27a: run_4f400(); break; 
+                case 0x27b: run_4f600(); break; 
+                case 0x27c: run_4f800(); break; 
+                case 0x27d: run_4fa00(); break; 
+                case 0x27e: run_4fc00(); break; 
+                case 0x27f: run_4fe00(); break; 
+                case 0x280: run_50000(); break; 
+                case 0x281: run_50200(); break; 
+                case 0x282: run_50400(); break; 
+                case 0x283: run_50600(); break; 
+                case 0x284: run_50800(); break; 
+                case 0x285: run_50a00(); break; 
+                case 0x286: run_50c00(); break; 
+                case 0x287: run_50e00(); break; 
+                case 0x288: run_51000(); break; 
+                case 0x289: run_51200(); break; 
+                case 0x28a: run_51400(); break; 
+                case 0x28b: run_51600(); break; 
+                case 0x28c: run_51800(); break; 
+                case 0x28d: run_51a00(); break; 
+                case 0x28e: run_51c00(); break; 
+                case 0x28f: run_51e00(); break; 
+                case 0x290: run_52000(); break; 
+                case 0x291: run_52200(); break; 
+                case 0x292: run_52400(); break; 
+                case 0x293: run_52600(); break; 
+                case 0x294: run_52800(); break; 
+                case 0x295: run_52a00(); break; 
+                case 0x296: run_52c00(); break; 
+                case 0x297: run_52e00(); break; 
+                case 0x298: run_53000(); break; 
+                case 0x299: run_53200(); break; 
+                case 0x29a: run_53400(); break; 
+                case 0x29b: run_53600(); break; 
+                case 0x29c: run_53800(); break; 
+                case 0x29d: run_53a00(); break; 
+                case 0x29e: run_53c00(); break; 
+                case 0x29f: run_53e00(); break; 
+                case 0x2a0: run_54000(); break; 
+                case 0x2a1: run_54200(); break; 
+                case 0x2a2: run_54400(); break; 
+                case 0x2a3: run_54600(); break; 
+                case 0x2a4: run_54800(); break; 
+                case 0x2a5: run_54a00(); break; 
+                case 0x2a6: run_54c00(); break; 
+                case 0x2a7: run_54e00(); break; 
+                case 0x2a8: run_55000(); break; 
+                case 0x2a9: run_55200(); break; 
+                case 0x2aa: run_55400(); break; 
+                case 0x2ab: run_55600(); break; 
+                case 0x2ac: run_55800(); break; 
+                case 0x2ad: run_55a00(); break; 
+                case 0x2ae: run_55c00(); break; 
+                case 0x2af: run_55e00(); break; 
+                case 0x2b0: run_56000(); break; 
+                case 0x2b1: run_56200(); break; 
+                case 0x2b2: run_56400(); break; 
+                case 0x2b3: run_56600(); break; 
+                case 0x2b4: run_56800(); break; 
+                case 0x2b5: run_56a00(); break; 
+                case 0x2b6: run_56c00(); break; 
+                case 0x2b7: run_56e00(); break; 
+                case 0x2b8: run_57000(); break; 
+                case 0x2b9: run_57200(); break; 
+                case 0x2ba: run_57400(); break; 
+                case 0x2bb: run_57600(); break; 
+                case 0x2bc: run_57800(); break; 
+                case 0x2bd: run_57a00(); break; 
+                case 0x2be: run_57c00(); break; 
+                case 0x2bf: run_57e00(); break; 
+                case 0x2c0: run_58000(); break; 
+                case 0x2c1: run_58200(); break; 
+                case 0x2c2: run_58400(); break; 
+                case 0x2c3: run_58600(); break; 
+                case 0x2c4: run_58800(); break; 
+                case 0x2c5: run_58a00(); break; 
+                case 0x2c6: run_58c00(); break; 
+                case 0x2c7: run_58e00(); break; 
+                case 0x2c8: run_59000(); break; 
+                case 0x2c9: run_59200(); break; 
+                case 0x2ca: run_59400(); break; 
+                case 0x2cb: run_59600(); break; 
+                case 0x2cc: run_59800(); break; 
+                case 0x2cd: run_59a00(); break; 
+                case 0x2ce: run_59c00(); break; 
+                case 0x2cf: run_59e00(); break; 
+                case 0x2d0: run_5a000(); break; 
+                case 0x2d1: run_5a200(); break; 
+                case 0x2d2: run_5a400(); break; 
+                case 0x2d3: run_5a600(); break; 
+                case 0x2d4: run_5a800(); break; 
+                case 0x2d5: run_5aa00(); break; 
+                case 0x2d6: run_5ac00(); break; 
+                case 0x2d7: run_5ae00(); break; 
+                case 0x2d8: run_5b000(); break; 
+                case 0x2d9: run_5b200(); break; 
+                case 0x2da: run_5b400(); break; 
+                case 0x2db: run_5b600(); break; 
+                case 0x2dc: run_5b800(); break; 
+                case 0x2dd: run_5ba00(); break; 
+                case 0x2de: run_5bc00(); break; 
+                case 0x2df: run_5be00(); break; 
+                case 0x2e0: run_5c000(); break; 
+                case 0x2e1: run_5c200(); break; 
+                case 0x2e2: run_5c400(); break; 
+                case 0x2e3: run_5c600(); break; 
+                case 0x2e4: run_5c800(); break; 
+                case 0x2e5: run_5ca00(); break; 
+                case 0x2e6: run_5cc00(); break; 
+                case 0x2e7: run_5ce00(); break; 
+                case 0x2e8: run_5d000(); break; 
+                case 0x2e9: run_5d200(); break; 
+                case 0x2ea: run_5d400(); break; 
+                case 0x2eb: run_5d600(); break; 
+                case 0x2ec: run_5d800(); break; 
+                case 0x2ed: run_5da00(); break; 
+                case 0x2ee: run_5dc00(); break; 
+                case 0x2ef: run_5de00(); break; 
+                case 0x2f0: run_5e000(); break; 
+                case 0x2f1: run_5e200(); break; 
+                case 0x2f2: run_5e400(); break; 
+                case 0x2f3: run_5e600(); break; 
+                case 0x2f4: run_5e800(); break; 
+                case 0x2f5: run_5ea00(); break; 
+                case 0x2f6: run_5ec00(); break; 
+                case 0x2f7: run_5ee00(); break; 
+                case 0x2f8: run_5f000(); break; 
+                case 0x2f9: run_5f200(); break; 
+                case 0x2fa: run_5f400(); break; 
+                case 0x2fb: run_5f600(); break; 
+                case 0x2fc: run_5f800(); break; 
+                case 0x2fd: run_5fa00(); break; 
+                case 0x2fe: run_5fc00(); break; 
+                case 0x2ff: run_5fe00(); break; 
+                case 0x300: run_60000(); break; 
+                case 0x301: run_60200(); break; 
+                case 0x302: run_60400(); break; 
+                case 0x303: run_60600(); break; 
+                case 0x304: run_60800(); break; 
+                case 0x305: run_60a00(); break; 
+                case 0x306: run_60c00(); break; 
+                case 0x307: run_60e00(); break; 
+                case 0x308: run_61000(); break; 
+                case 0x309: run_61200(); break; 
+                case 0x30a: run_61400(); break; 
+                case 0x30b: run_61600(); break; 
+                case 0x30c: run_61800(); break; 
+                case 0x30d: run_61a00(); break; 
+                case 0x30e: run_61c00(); break; 
+                case 0x30f: run_61e00(); break; 
+                case 0x310: run_62000(); break; 
+                case 0x311: run_62200(); break; 
+                case 0x312: run_62400(); break; 
+                case 0x313: run_62600(); break; 
+                case 0x314: run_62800(); break; 
+                case 0x315: run_62a00(); break; 
+                case 0x316: run_62c00(); break; 
+                case 0x317: run_62e00(); break; 
+                case 0x318: run_63000(); break; 
+                case 0x319: run_63200(); break; 
+                case 0x31a: run_63400(); break; 
+                case 0x31b: run_63600(); break; 
+                case 0x31c: run_63800(); break; 
+                case 0x31d: run_63a00(); break; 
+                case 0x31e: run_63c00(); break; 
+                case 0x31f: run_63e00(); break; 
+                case 0x320: run_64000(); break; 
+                case 0x321: run_64200(); break; 
+                case 0x322: run_64400(); break; 
+                case 0x323: run_64600(); break; 
+                case 0x324: run_64800(); break; 
+                case 0x325: run_64a00(); break; 
+                case 0x326: run_64c00(); break; 
+                case 0x327: run_64e00(); break; 
+                case 0x328: run_65000(); break; 
+                case 0x329: run_65200(); break; 
+                case 0x32a: run_65400(); break; 
+                case 0x32b: run_65600(); break; 
+                case 0x32c: run_65800(); break; 
+                case 0x32d: run_65a00(); break; 
+                case 0x32e: run_65c00(); break; 
+                case 0x32f: run_65e00(); break; 
+                case 0x330: run_66000(); break; 
+                case 0x331: run_66200(); break; 
+                case 0x332: run_66400(); break; 
+                case 0x333: run_66600(); break; 
+                case 0x334: run_66800(); break; 
+                case 0x335: run_66a00(); break; 
+                case 0x336: run_66c00(); break; 
+                case 0x337: run_66e00(); break; 
+                case 0x338: run_67000(); break; 
+                case 0x339: run_67200(); break; 
+                case 0x33a: run_67400(); break; 
+                case 0x33b: run_67600(); break; 
+                case 0x33c: run_67800(); break; 
+                case 0x33d: run_67a00(); break; 
+                case 0x33e: run_67c00(); break; 
+                case 0x33f: run_67e00(); break; 
+                case 0x340: run_68000(); break; 
+                case 0x341: run_68200(); break; 
+                case 0x342: run_68400(); break; 
+                case 0x343: run_68600(); break; 
+                case 0x344: run_68800(); break; 
+                case 0x345: run_68a00(); break; 
+                case 0x346: run_68c00(); break; 
+                case 0x347: run_68e00(); break; 
+                case 0x348: run_69000(); break; 
+                case 0x349: run_69200(); break; 
+                case 0x34a: run_69400(); break; 
+                case 0x34b: run_69600(); break; 
+                case 0x34c: run_69800(); break; 
+                case 0x34d: run_69a00(); break; 
+                case 0x34e: run_69c00(); break; 
+                case 0x34f: run_69e00(); break; 
+                case 0x350: run_6a000(); break; 
+                case 0x351: run_6a200(); break; 
+                case 0x352: run_6a400(); break; 
+                case 0x353: run_6a600(); break; 
+                case 0x354: run_6a800(); break; 
+                case 0x355: run_6aa00(); break; 
+                case 0x356: run_6ac00(); break; 
+                case 0x357: run_6ae00(); break; 
+                case 0x358: run_6b000(); break; 
+                case 0x359: run_6b200(); break; 
+                case 0x35a: run_6b400(); break; 
+                case 0x35b: run_6b600(); break; 
+                case 0x35c: run_6b800(); break; 
+                case 0x35d: run_6ba00(); break; 
+                case 0x35e: run_6bc00(); break; 
+                case 0x35f: run_6be00(); break; 
+                case 0x360: run_6c000(); break; 
+                case 0x361: run_6c200(); break; 
+                case 0x362: run_6c400(); break; 
+                default: throw new ExecutionException("invalid address 0x" + Long.toString(this.pc&0xffffffffL,16) + ": r2: " + r2);
+            }
+        }
+    }
+
+    public AcmeCrossAssembler() {
+        super(4096,65536);
+        initPages(_data1,0x6c600,false);
+        initPages(_data2,0x6c608,false);
+        initPages(_data3,0x6d000,true);
+        initPages(_data4,0x71548,false);
+        initPages(_data5,0x73010,false);
+        clearPages(0x7378c,0x48);
+        clearPages(0x738b0,0x1012);
+    }
+
+    protected int entryPoint() { return 0x10400; }
+    protected int heapStart() { return 0x778f8; }
+    protected int gp() { return 0x7b010; }
+    public static void main(String[] args) throws Exception {
+        AcmeCrossAssembler me = new AcmeCrossAssembler();
+        int status = me.run("Acme",args);
+        System.exit(status);
+    }
+
+    protected void _execute() throws ExecutionException { trampoline(); }
+
+    protected void setCPUState(CPUState state) {
+        r1=state.r[1];
+        r2=state.r[2];
+        r3=state.r[3];
+        r4=state.r[4];
+        r5=state.r[5];
+        r6=state.r[6];
+        r7=state.r[7];
+        r8=state.r[8];
+        r9=state.r[9];
+        r10=state.r[10];
+        r11=state.r[11];
+        r12=state.r[12];
+        r13=state.r[13];
+        r14=state.r[14];
+        r15=state.r[15];
+        r16=state.r[16];
+        r17=state.r[17];
+        r18=state.r[18];
+        r19=state.r[19];
+        r20=state.r[20];
+        r21=state.r[21];
+        r22=state.r[22];
+        r23=state.r[23];
+        r24=state.r[24];
+        r25=state.r[25];
+        r26=state.r[26];
+        r27=state.r[27];
+        r28=state.r[28];
+        r29=state.r[29];
+        r30=state.r[30];
+        r31=state.r[31];
+        f0=state.f[0];
+        f1=state.f[1];
+        f2=state.f[2];
+        f3=state.f[3];
+        f4=state.f[4];
+        f5=state.f[5];
+        f6=state.f[6];
+        f7=state.f[7];
+        f8=state.f[8];
+        f9=state.f[9];
+        f10=state.f[10];
+        f11=state.f[11];
+        f12=state.f[12];
+        f13=state.f[13];
+        f14=state.f[14];
+        f15=state.f[15];
+        f16=state.f[16];
+        f17=state.f[17];
+        f18=state.f[18];
+        f19=state.f[19];
+        f20=state.f[20];
+        f21=state.f[21];
+        f22=state.f[22];
+        f23=state.f[23];
+        f24=state.f[24];
+        f25=state.f[25];
+        f26=state.f[26];
+        f27=state.f[27];
+        f28=state.f[28];
+        f29=state.f[29];
+        f30=state.f[30];
+        f31=state.f[31];
+        hi=state.hi; lo=state.lo; fcsr=state.fcsr;
+        pc=state.pc;
+    }
+    protected void getCPUState(CPUState state) {
+        state.r[1]=r1;
+        state.r[2]=r2;
+        state.r[3]=r3;
+        state.r[4]=r4;
+        state.r[5]=r5;
+        state.r[6]=r6;
+        state.r[7]=r7;
+        state.r[8]=r8;
+        state.r[9]=r9;
+        state.r[10]=r10;
+        state.r[11]=r11;
+        state.r[12]=r12;
+        state.r[13]=r13;
+        state.r[14]=r14;
+        state.r[15]=r15;
+        state.r[16]=r16;
+        state.r[17]=r17;
+        state.r[18]=r18;
+        state.r[19]=r19;
+        state.r[20]=r20;
+        state.r[21]=r21;
+        state.r[22]=r22;
+        state.r[23]=r23;
+        state.r[24]=r24;
+        state.r[25]=r25;
+        state.r[26]=r26;
+        state.r[27]=r27;
+        state.r[28]=r28;
+        state.r[29]=r29;
+        state.r[30]=r30;
+        state.r[31]=r31;
+        state.f[0]=f0;
+        state.f[1]=f1;
+        state.f[2]=f2;
+        state.f[3]=f3;
+        state.f[4]=f4;
+        state.f[5]=f5;
+        state.f[6]=f6;
+        state.f[7]=f7;
+        state.f[8]=f8;
+        state.f[9]=f9;
+        state.f[10]=f10;
+        state.f[11]=f11;
+        state.f[12]=f12;
+        state.f[13]=f13;
+        state.f[14]=f14;
+        state.f[15]=f15;
+        state.f[16]=f16;
+        state.f[17]=f17;
+        state.f[18]=f18;
+        state.f[19]=f19;
+        state.f[20]=f20;
+        state.f[21]=f21;
+        state.f[22]=f22;
+        state.f[23]=f23;
+        state.f[24]=f24;
+        state.f[25]=f25;
+        state.f[26]=f26;
+        state.f[27]=f27;
+        state.f[28]=f28;
+        state.f[29]=f29;
+        state.f[30]=f30;
+        state.f[31]=f31;
+        state.hi=hi; state.lo=lo; state.fcsr=fcsr;
+        state.pc=pc;
+    }
+
+    private static final java.util.Hashtable symbols = new java.util.Hashtable();
+    static {
+        symbols.put("setgrent",new Integer(0x53c00));
+        symbols.put("chroot",new Integer(0x4cc00));
+        symbols.put("strcpy",new Integer(0x42e00));
+        symbols.put("cliargs_get_rest",new Integer(0x16e00));
+        symbols.put("flow_store_doloop_condition",new Integer(0x19600));
+        symbols.put("fabs",new Integer(0x32a00));
+        symbols.put("waitpid",new Integer(0x4ae00));
+        symbols.put("vcpu_set_pc",new Integer(0x27e00));
+        symbols.put("flow_parse_block_else_block",new Integer(0x19a00));
+        symbols.put("Output_passinit",new Integer(0x27600));
+        symbols.put("Input_until_terminator",new Integer(0x1d800));
+        symbols.put("GetQuotedByte",new Integer(0x1c600));
+        symbols.put("getgid",new Integer(0x496c4));
+        symbols.put("sysconf",new Integer(0x4a400));
+        symbols.put("printf",new Integer(0x3fc00));
+        symbols.put("vsprintf",new Integer(0x65200));
+        symbols.put("utime",new Integer(0x4a800));
+        symbols.put("Input_skip_or_store_block",new Integer(0x1d400));
+        symbols.put("getlogin",new Integer(0x54e00));
+        symbols.put("recv",new Integer(0x4fe00));
+        symbols.put("Input_skip_remainder",new Integer(0x1c800));
+        symbols.put("connect",new Integer(0x4e200));
+        symbols.put("ungetc",new Integer(0x6a800));
+        symbols.put("GetByte",new Integer(0x1c000));
+        symbols.put("safe_malloc",new Integer(0x1b400));
+        symbols.put("geteuid",new Integer(0x496b4));
+        symbols.put("symbol_fix_forward_anon_name",new Integer(0x30800));
+        symbols.put("memmove",new Integer(0x5b600));
+        symbols.put("keyword_is_65816mnemo",new Integer(0x24e00));
+        symbols.put("snprintf",new Integer(0x41c00));
+        symbols.put("pathconf",new Integer(0x4c800));
+        symbols.put("Tree_easy_scan",new Integer(0x31000));
+        symbols.put("mknod",new Integer(0x4ce00));
+        symbols.put("getgrgid",new Integer(0x53800));
+        symbols.put("dump_tree",new Integer(0x31400));
+        symbols.put("getenv",new Integer(0x3e000));
+        symbols.put("fchmod",new Integer(0x4c000));
+        symbols.put("floor",new Integer(0x37600));
+        symbols.put("getegid",new Integer(0x496d4));
+        symbols.put("setpriority",new Integer(0x4e000));
+        symbols.put("getpriority",new Integer(0x4de00));
+        symbols.put("usleep",new Integer(0x4d200));
+        symbols.put("typesystem_want_imm",new Integer(0x32000));
+        symbols.put("getpagesize",new Integer(0x48b80));
+        symbols.put("fchown",new Integer(0x4ba00));
+        symbols.put("fgets",new Integer(0x59400));
+        symbols.put("dirname",new Integer(0x55000));
+        symbols.put("Section_finalize",new Integer(0x2e600));
+        symbols.put("Throw_warning",new Integer(0x1ac00));
+        symbols.put("memcpy",new Integer(0x48fdc));
+        symbols.put("DynaBuf_to_lower",new Integer(0x18000));
+        symbols.put("Throw_error",new Integer(0x1b000));
+        symbols.put("ALU_any_result",new Integer(0x16400));
+        symbols.put("readlink",new Integer(0x4b600));
+        symbols.put("puts",new Integer(0x40400));
+        symbols.put("dup2",new Integer(0x4ac00));
+        symbols.put("mbrtowc",new Integer(0x66200));
+        symbols.put("getpass",new Integer(0x54a00));
+        symbols.put("getuid",new Integer(0x496a4));
+        symbols.put("malloc",new Integer(0x3e800));
+        symbols.put("isatty",new Integer(0x5a200));
+        symbols.put("symbol_define",new Integer(0x30200));
+        symbols.put("iswspace",new Integer(0x65e00));
+        symbols.put("endpwent",new Integer(0x54800));
+        symbols.put("sleep",new Integer(0x48af0));
+        symbols.put("vsnprintf",new Integer(0x64e00));
+        symbols.put("recvfrom",new Integer(0x4f800));
+        symbols.put("strtoul",new Integer(0x5fc00));
+        symbols.put("ACME_finalize",new Integer(0x11800));
+        symbols.put("typesystem_force_address_statement",new Integer(0x31e00));
+        symbols.put("gethostbyaddr",new Integer(0x53200));
+        symbols.put("rmdir",new Integer(0x4a200));
+        symbols.put("Input_append_keyword_to_global_dynabuf",new Integer(0x1dc00));
+        symbols.put("socket",new Integer(0x4e400));
+        symbols.put("select",new Integer(0x4fa00));
+        symbols.put("readdir",new Integer(0x52600));
+        symbols.put("lchown",new Integer(0x4bc00));
+        symbols.put("setgroups",new Integer(0x50e00));
+        symbols.put("fflush",new Integer(0x39a00));
+        symbols.put("cliargs_safe_get_next",new Integer(0x16a00));
+        symbols.put("ftruncate",new Integer(0x4d000));
+        symbols.put("realpath",new Integer(0x4d800));
+        symbols.put("keyword_is_6510mnemo",new Integer(0x23000));
+        symbols.put("chown",new Integer(0x4b800));
+        symbols.put("send",new Integer(0x4fc00));
+        symbols.put("vcpu_check_and_set_reg_length",new Integer(0x17200));
+        symbols.put("Output_init",new Integer(0x26e00));
+        symbols.put("chmod",new Integer(0x4be00));
+        symbols.put("alarm",new Integer(0x49a64));
+        symbols.put("Parse_optional_block",new Integer(0x1b600));
+        symbols.put("strtol",new Integer(0x43600));
+        symbols.put("pipe",new Integer(0x4aa00));
+        symbols.put("encoding_passinit",new Integer(0x18e00));
+        symbols.put("uname",new Integer(0x55400));
+        symbols.put("symbol_parse_definition",new Integer(0x2fc00));
+        symbols.put("Output_start_segment",new Integer(0x27a00));
+        symbols.put("accept",new Integer(0x4ea00));
+        symbols.put("rint",new Integer(0x38000));
+        symbols.put("basename",new Integer(0x55200));
+        symbols.put("ALU_optional_defined_int",new Integer(0x15a00));
+        symbols.put("output_set_output_filename",new Integer(0x26c00));
+        symbols.put("DynaBuf_get_copy",new Integer(0x17a00));
+        symbols.put("output_set_output_format",new Integer(0x26800));
+        symbols.put("strtod",new Integer(0x68800));
+        symbols.put("Throw_first_pass_warning",new Integer(0x1ae00));
+        symbols.put("Parse_until_eob_or_eof",new Integer(0x1a400));
+        symbols.put("sysctl",new Integer(0x4dc00));
+        symbols.put("fstat",new Integer(0x62e00));
+        symbols.put("fprintf",new Integer(0x3bc00));
+        symbols.put("cputype_passinit",new Integer(0x17400));
+        symbols.put("setpwent",new Integer(0x54600));
+        symbols.put("bind",new Integer(0x4f000));
+        symbols.put("inet_addr",new Integer(0x56200));
+        symbols.put("mkfifo",new Integer(0x4d400));
+        symbols.put("chdir",new Integer(0x4a600));
+        symbols.put("Input_read_keyword",new Integer(0x1ec00));
+        symbols.put("cputype_find",new Integer(0x17000));
+        symbols.put("initgroups",new Integer(0x56600));
+        symbols.put("Macro_parse_definition",new Integer(0x20600));
+        symbols.put("endgrent",new Integer(0x53e00));
+        symbols.put("setsockopt",new Integer(0x4ee00));
+        symbols.put("fseek",new Integer(0x3d400));
+        symbols.put("cos",new Integer(0x32800));
+        symbols.put("memchr",new Integer(0x5b400));
+        symbols.put("output_le16",new Integer(0x26000));
+        symbols.put("umask",new Integer(0x49694));
+        symbols.put("symbol_set_value",new Integer(0x2f600));
+        symbols.put("symbol_find",new Integer(0x2f400));
+        symbols.put("lstat",new Integer(0x4c200));
+        symbols.put("sin",new Integer(0x32c00));
+        symbols.put("setgid",new Integer(0x50a00));
+        symbols.put("signal",new Integer(0x5ea00));
+        symbols.put("output_8",new Integer(0x25e00));
+        symbols.put("strncmp",new Integer(0x43000));
+        symbols.put("DynaBuf_create",new Integer(0x17600));
+        symbols.put("pow",new Integer(0x33400));
+        symbols.put("keyword_is_6502mnemo",new Integer(0x22600));
+        symbols.put("strncpy",new Integer(0x5f400));
+        symbols.put("DynaBuf_add_string",new Integer(0x17e00));
+        symbols.put("Input_read_filename",new Integer(0x1fc00));
+        symbols.put("sync",new Integer(0x51e00));
+        symbols.put("ALU_int_result",new Integer(0x15c00));
+        symbols.put("sendto",new Integer(0x4f600));
+        symbols.put("realloc",new Integer(0x40600));
+        symbols.put("vcpu_get_statement_size",new Integer(0x28200));
+        symbols.put("Section_passinit",new Integer(0x2e800));
+        symbols.put("listen",new Integer(0x4f200));
+        symbols.put("fork",new Integer(0x62c00));
+        symbols.put("sscanf",new Integer(0x5f000));
+        symbols.put("getgrent",new Integer(0x53a00));
+        symbols.put("sigaction",new Integer(0x52200));
+        symbols.put("fread",new Integer(0x3c600));
+        symbols.put("inet_aton",new Integer(0x55e00));
+        symbols.put("Input_read_and_lower_keyword",new Integer(0x1f400));
+        symbols.put("symlink",new Integer(0x4b400));
+        symbols.put("encoding_find",new Integer(0x19200));
+        symbols.put("Tree_add_table",new Integer(0x30e00));
+        symbols.put("DynaBuf_init",new Integer(0x18200));
+        symbols.put("fopen",new Integer(0x3b800));
+        symbols.put("memset",new Integer(0x48fec));
+        symbols.put("main",new Integer(0x11c00));
+        symbols.put("typesystem_want_addr",new Integer(0x32200));
+        symbols.put("Output_end_segment",new Integer(0x27800));
+        symbols.put("Output_fake",new Integer(0x25c00));
+        symbols.put("add_node_to_tree",new Integer(0x30c00));
+        symbols.put("pseudoopcodes_init",new Integer(0x2e000));
+        symbols.put("DynaBuf_append",new Integer(0x17c00));
+        symbols.put("matherr",new Integer(0x37c00));
+        symbols.put("fclose",new Integer(0x39200));
+        symbols.put("inet_ntoa",new Integer(0x52a00));
+        symbols.put("getppid",new Integer(0x491bc));
+        symbols.put("opendir",new Integer(0x52400));
+        symbols.put("getgroups",new Integer(0x50000));
+        symbols.put("keyword_is_c64dtv2mnemo",new Integer(0x23a00));
+        symbols.put("getgrouplist",new Integer(0x56400));
+        symbols.put("seteuid",new Integer(0x50800));
+        symbols.put("keyword_is_65c02mnemo",new Integer(0x24400));
+        symbols.put("putc",new Integer(0x40000));
+        symbols.put("output_initmem",new Integer(0x26600));
+        symbols.put("finite",new Integer(0x37400));
+        symbols.put("herror",new Integer(0x53000));
+        symbols.put("strcmp",new Integer(0x42c00));
+        symbols.put("flow_forloop",new Integer(0x19400));
+        symbols.put("shutdown",new Integer(0x4f400));
+        symbols.put("tan",new Integer(0x32e00));
+        symbols.put("ttyname",new Integer(0x52000));
+        symbols.put("vfiprintf",new Integer(0x64a00));
+        symbols.put("getpwuid",new Integer(0x54200));
+        symbols.put("Input_read_zone_and_keyword",new Integer(0x1e400));
+        symbols.put("dup",new Integer(0x4c600));
+        symbols.put("copysign",new Integer(0x38800));
+        symbols.put("getcwd",new Integer(0x4b000));
+        symbols.put("Section_new_zone",new Integer(0x2e400));
+        symbols.put("encoding_load",new Integer(0x19000));
+        symbols.put("gethostbyname",new Integer(0x53400));
+        symbols.put("getpwnam",new Integer(0x54000));
+        symbols.put("getservbyname",new Integer(0x52c00));
+        symbols.put("atan",new Integer(0x32400));
+        symbols.put("gethostname",new Integer(0x55a00));
+        symbols.put("sprintf",new Integer(0x42000));
+        symbols.put("pseudoopcode_parse",new Integer(0x2e200));
+        symbols.put("Tree_hard_scan",new Integer(0x31200));
+        symbols.put("strtof",new Integer(0x68a00));
+        symbols.put("atexit",new Integer(0x38a00));
+        symbols.put("cliargs_get_next",new Integer(0x16600));
+        symbols.put("output_le32",new Integer(0x26400));
+        symbols.put("asin",new Integer(0x33200));
+        symbols.put("setlocale",new Integer(0x5b000));
+        symbols.put("getpeername",new Integer(0x50400));
+        symbols.put("Throw_serious_error",new Integer(0x1b200));
+        symbols.put("nanf",new Integer(0x66a00));
+        symbols.put("cliargs_init",new Integer(0x16c00));
+        symbols.put("scalbn",new Integer(0x38400));
+        symbols.put("vfork",new Integer(0x4ca00));
+        symbols.put("ALU_liberal_int",new Integer(0x16200));
+        symbols.put("symbols_vicelabels",new Integer(0x30600));
+        symbols.put("fsync",new Integer(0x51200));
+        symbols.put("Mnemo_init",new Integer(0x22400));
+        symbols.put("fputc",new Integer(0x3c000));
+        symbols.put("symbol_set_label",new Integer(0x2f800));
+        symbols.put("DynaBuf_enlarge",new Integer(0x17800));
+        symbols.put("getsockopt",new Integer(0x4ec00));
+        symbols.put("typesystem_force_address_block",new Integer(0x31c00));
+        symbols.put("hstrerror",new Integer(0x52e00));
+        symbols.put("vcpu_end_statement",new Integer(0x28400));
+        symbols.put("nan",new Integer(0x37e00));
+        symbols.put("Macro_parse_call",new Integer(0x20a00));
+        symbols.put("encoding_encode_char",new Integer(0x18c00));
+        symbols.put("Input_new_file",new Integer(0x1be00));
+        symbols.put("localeconv",new Integer(0x5b200));
+        symbols.put("Tree_dump_forest",new Integer(0x31800));
+        symbols.put("Bug_found",new Integer(0x1b800));
+        symbols.put("Output_save_file",new Integer(0x27000));
+        symbols.put("fwrite",new Integer(0x3dc00));
+        symbols.put("vcpu_read_pc",new Integer(0x28000));
+        symbols.put("access",new Integer(0x4a000));
+        symbols.put("ALU_any_int",new Integer(0x15e00));
+        symbols.put("notreallypo_setpc",new Integer(0x2de00));
+        symbols.put("getdents",new Integer(0x4c400));
+        symbols.put("Input_accept_comma",new Integer(0x20000));
+        symbols.put("exit",new Integer(0x38e00));
+        symbols.put("klogctl",new Integer(0x4d600));
+        symbols.put("typesystem_says_address",new Integer(0x31a00));
+        symbols.put("getgrnam",new Integer(0x53600));
+        symbols.put("make_hash",new Integer(0x30a00));
+        symbols.put("output_prefer_cbm_file_format",new Integer(0x26a00));
+        symbols.put("AnyOS_entry",new Integer(0x28600));
+        symbols.put("Macro_init",new Integer(0x20400));
+        symbols.put("ALU_init",new Integer(0x15800));
+        symbols.put("getpwent",new Integer(0x54400));
+        symbols.put("daemon",new Integer(0x55c00));
+        symbols.put("strlen",new Integer(0x10268));
+        symbols.put("open",new Integer(0x63000));
+        symbols.put("Input_get_force_bit",new Integer(0x20200));
+        symbols.put("fputs",new Integer(0x59a00));
+        symbols.put("setsid",new Integer(0x51000));
+        symbols.put("setegid",new Integer(0x50c00));
+        symbols.put("closedir",new Integer(0x52800));
+        symbols.put("cliargs_handle_options",new Integer(0x16800));
+        symbols.put("acos",new Integer(0x33000));
+        symbols.put("output_le24",new Integer(0x26200));
+        symbols.put("vasprintf",new Integer(0x54c00));
+        symbols.put("Input_ensure_EOS",new Integer(0x1ce00));
+        symbols.put("setuid",new Integer(0x50600));
+        symbols.put("mkdir",new Integer(0x49e00));
+        symbols.put("ALU_defined_int",new Integer(0x16000));
+        symbols.put("wcrtomb",new Integer(0x6ac00));
+        symbols.put("close",new Integer(0x62a00));
+        symbols.put("symbols_list",new Integer(0x30400));
+        symbols.put("flow_parse_and_close_file",new Integer(0x19c00));
+        symbols.put("flow_doloop",new Integer(0x19800));
+        symbols.put("_call_helper",new Integer(0x10284));
+        symbols.put("vfprintf",new Integer(0x48000));
+        symbols.put("fputwc",new Integer(0x65c00));
+        symbols.put("raise",new Integer(0x5e800));
+        symbols.put("free",new Integer(0x3ea00));
+        symbols.put("getsockname",new Integer(0x50200));
+    }
+    public int lookupSymbol(String symbol) { Integer i = (Integer) symbols.get(symbol); return i==null ? -1 : i.intValue(); }
+
+}
diff --git a/src/main/java/jace/assembly/AssemblyHandler.java b/src/main/java/jace/assembly/AssemblyHandler.java
new file mode 100644
index 0000000..0d0c531
--- /dev/null
+++ b/src/main/java/jace/assembly/AssemblyHandler.java
@@ -0,0 +1,53 @@
+package jace.assembly;
+
+import jace.Emulator;
+import jace.core.RAM;
+import jace.ide.Program;
+import jace.ide.CompileResult;
+import jace.ide.LanguageHandler;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * @author blurry
+ */
+public class AssemblyHandler implements LanguageHandler<File> {
+    @Override
+    public String getNewDocumentContent() {
+        return "\t\t*= $300;\n\t\t!cpu 65c02;\n;--- Insert your code here ---\n";
+    }    
+
+    @Override
+    public CompileResult<File> compile(Program proxy) {
+        AcmeCompiler compiler = new AcmeCompiler();
+        compiler.compile(proxy);
+        return compiler;
+    }
+
+    @Override
+    public void execute(CompileResult<File> lastResult) {
+        if (lastResult.isSuccessful()) {
+            try {
+                Emulator.computer.pause();
+                RAM memory = Emulator.computer.getMemory();
+                FileInputStream input = new FileInputStream(lastResult.getCompiledAsset());
+                int startLSB = input.read();
+                int startMSB = input.read();
+                int pos = startLSB + startMSB << 8;
+                Emulator.computer.getCpu().JSR(pos);
+                int next;
+                while ((next=input.read()) != -1) {
+                    memory.write(pos++, (byte) next, false, true);
+                }
+                Emulator.computer.resume();
+            } catch (IOException ex) {
+                Logger.getLogger(AssemblyHandler.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        }
+        lastResult.getCompiledAsset().delete();
+    }
+}
diff --git a/src/main/java/jace/core/CPU.java b/src/main/java/jace/core/CPU.java
index 83e7f5f..8693822 100644
--- a/src/main/java/jace/core/CPU.java
+++ b/src/main/java/jace/core/CPU.java
@@ -158,4 +158,6 @@ public abstract class CPU extends Device {
     @Override
     public void attach() {
     }
+
+    abstract public void JSR(int pointer);
 }
\ No newline at end of file
diff --git a/src/main/java/jace/core/Keyboard.java b/src/main/java/jace/core/Keyboard.java
index 66ab1fe..7820dc4 100644
--- a/src/main/java/jace/core/Keyboard.java
+++ b/src/main/java/jace/core/Keyboard.java
@@ -310,6 +310,7 @@ public class Keyboard implements Reconfigurable {
     }
 
     public static void pasteFromString(String text) {
+        text = text.replaceAll("\\r?\\n|\\r", (char) 0x0d + "");
         pasteBuffer = new StringReader(text);
     }
 
@@ -319,7 +320,7 @@ public class Keyboard implements Reconfigurable {
             Clipboard clip = Toolkit.getDefaultToolkit().getSystemClipboard();
             String contents = (String) clip.getData(DataFlavor.stringFlavor);
             if (contents != null && !"".equals(contents)) {
-                contents = contents.replaceAll("\\n(\\r)?", (char) 0x0d + "");
+                contents = contents.replaceAll("\\r?\\n|\\r", (char) 0x0d + "");
                 pasteBuffer = new StringReader(contents);
             }
         } catch (UnsupportedFlavorException | IOException ex) {
diff --git a/src/main/java/jace/ide/CompileResult.java b/src/main/java/jace/ide/CompileResult.java
new file mode 100644
index 0000000..db88503
--- /dev/null
+++ b/src/main/java/jace/ide/CompileResult.java
@@ -0,0 +1,21 @@
+package jace.ide;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * @author blurry
+ */
+public interface CompileResult<T> {
+
+    public boolean isSuccessful();
+    
+    public T getCompiledAsset();
+    
+    public Map<Integer, String> getErrorsAndWarnings();
+
+    public List<String> getOtherMessages();
+
+    public List<String> getRawOutput();    
+}
diff --git a/src/main/java/jace/ide/IdeController.java b/src/main/java/jace/ide/IdeController.java
new file mode 100644
index 0000000..86e01d3
--- /dev/null
+++ b/src/main/java/jace/ide/IdeController.java
@@ -0,0 +1,245 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package jace.ide;
+
+import jace.ide.Program.DocumentType;
+import jace.ide.Program.Option;
+import java.io.File;
+import java.net.URL;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.ResourceBundle;
+import javafx.collections.ListChangeListener;
+import javafx.event.ActionEvent;
+import javafx.event.Event;
+import javafx.fxml.FXML;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.Tab;
+import javafx.scene.control.TabPane;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.control.ToolBar;
+import javafx.scene.web.WebView;
+import javafx.stage.FileChooser;
+
+/**
+ * FXML Controller class
+ *
+ * @author blurry
+ */
+public class IdeController {
+
+    @FXML // ResourceBundle that was given to the FXMLLoader
+    private ResourceBundle resources;
+
+    @FXML // URL location of the FXML file that was given to the FXMLLoader
+    private URL location;
+
+    @FXML // fx:id="saveMenuItem"
+    private MenuItem saveMenuItem; // Value injected by FXMLLoader
+
+    @FXML // fx:id="saveAllMenuItem"
+    private MenuItem saveAllMenuItem; // Value injected by FXMLLoader
+
+    @FXML // fx:id="saveAsMenuItem"
+    private MenuItem saveAsMenuItem; // Value injected by FXMLLoader
+
+    @FXML // fx:id="closeMenuItem"
+    private MenuItem closeMenuItem; // Value injected by FXMLLoader
+
+    @FXML // fx:id="closeAllMenuItem"
+    private MenuItem closeAllMenuItem; // Value injected by FXMLLoader
+
+    @FXML // fx:id="editMenu"
+    private Menu editMenu; // Value injected by FXMLLoader
+
+    @FXML // fx:id="runMenu"
+    private Menu runMenu; // Value injected by FXMLLoader
+
+    @FXML // fx:id="autocompile"
+    private ToggleGroup autocompile; // Value injected by FXMLLoader
+
+    @FXML // fx:id="tabPane"
+    private TabPane tabPane; // Value injected by FXMLLoader
+
+    @FXML // fx:id="statusBar"
+    private ToolBar statusBar; // Value injected by FXMLLoader
+
+    @FXML
+    void onCloseAllClicked(ActionEvent event) {
+        openDocuments.forEach((Tab t, Program proxy) -> {
+            if (!event.isConsumed()) {
+                closeTab(t, event);
+            }
+        });
+    }
+
+    @FXML
+    void onCloseClicked(ActionEvent event) {
+        getCurrentTab().ifPresent((t) -> closeTab(t, event));
+    }
+
+    public Optional<Tab> getCurrentTab() {
+        return Optional.ofNullable(tabPane.getSelectionModel().getSelectedItem());
+    }
+
+    public Optional<Program> getCurrentProgram() {
+        return getCurrentTab().map(t -> openDocuments.get(t));
+    }
+
+    @FXML
+    void newApplesoftBasicClicked(ActionEvent event) {
+        Program tab = createTab(DocumentType.applesoft, null);
+    }
+
+    @FXML
+    void newAssemblyListingClicked(ActionEvent event) {
+        createTab(DocumentType.assembly, null);
+    }
+
+    @FXML
+    void newHexdataClicked(ActionEvent event) {
+        createTab(DocumentType.hex, null);
+    }
+
+    @FXML
+    void newPlainTextClicked(ActionEvent event) {
+        createTab(DocumentType.plain, null);
+    }
+
+    Map<Tab, Program> openDocuments = new HashMap<>();
+    Map<Option, Object> globalOptions = new EnumMap<>(Option.class);
+
+    private Program createTab(DocumentType type, File document) {
+        WebView editor = new WebView();
+        Program proxy = new Program(type, globalOptions);
+        proxy.initEditor(editor, document);
+        Tab t = new Tab(proxy.getName(), editor);
+        tabPane.getTabs().add(t);
+        openDocuments.put(t, proxy);
+        t.setOnCloseRequest(this::handleCloseTabRequest);
+        return proxy;
+    }
+
+    private void handleCloseTabRequest(Event e) {
+        Tab t = (Tab) e.getTarget();
+        closeTab(t, e);
+    }
+
+    private void closeTab(Tab t, Event e) {
+        tabPane.getTabs().remove(t);
+        openDocuments.remove(t);
+    }
+
+    @FXML
+    void onOpenClicked(ActionEvent event) {
+        FileChooser chooser = new FileChooser();
+        chooser.setTitle("Open document");
+        for (DocumentType type : Program.DocumentType.values()) {
+            chooser.getExtensionFilters().add(
+                    new FileChooser.ExtensionFilter(type.name(), type.extensions)
+            );
+        }
+        chooser.getExtensionFilters().addAll(
+                new FileChooser.ExtensionFilter("All Files", "*.*")
+        );
+        File file = chooser.showOpenDialog(null);
+        if (file != null && file.isFile() && file.exists()) {
+            DocumentType type = DocumentType.fromFile(file);
+            createTab(type, file);
+        }
+    }
+
+    @FXML
+    void onSaveAllClicked(ActionEvent event) {
+        openDocuments.forEach((Tab t, Program p) -> {
+            if (p.isChanged()) {
+                if (p.getFile().isPresent()) {
+                    p.save(p.getFile().get());
+                    t.setText(p.getName());
+                } else {
+                    tabPane.getSelectionModel().select(t);
+                    onSaveAsClicked(event);
+                }
+            }
+        });
+    }
+
+    @FXML
+    void onSaveAsClicked(ActionEvent event) {
+        getCurrentProgram().ifPresent(program -> {
+            program.save(chooseFileToSave(program.getType()));
+            getCurrentTab().get().setText(program.getName());
+        });
+    }
+
+    @FXML
+    void onSaveClicked(ActionEvent event) {
+        getCurrentProgram().ifPresent(program -> {
+            program.save(
+                    program.getFile()
+                    .orElseGet(() -> chooseFileToSave(program.getType())));
+            getCurrentTab().get().setText(program.getName());
+        });
+    }
+
+    private File chooseFileToSave(DocumentType type) {
+        FileChooser chooser = new FileChooser();
+        chooser.setTitle("Save " + type.name() + " document");
+        chooser.getExtensionFilters().addAll(
+                new FileChooser.ExtensionFilter(type.name(), type.extensions),
+                new FileChooser.ExtensionFilter("All Files", "*.*")
+        );
+        return chooser.showSaveDialog(null);
+    }
+
+    @FXML
+    void executeClicked(ActionEvent event) {
+        getCurrentProgram().ifPresent(proxy -> proxy.execute());
+    }
+
+    @FXML
+    void testCompileClicked(ActionEvent event) {
+        getCurrentProgram().ifPresent(proxy -> proxy.test());
+    }
+
+    @FXML
+    void viewCompilerOutputClicked(ActionEvent event) {
+
+    }
+
+    @FXML
+    void viewSymbolTableClicked(ActionEvent event) {
+
+    }
+
+    @FXML // This method is called by the FXMLLoader when initialization is complete
+    public void initialize() {
+        assert saveMenuItem != null : "fx:id=\"saveMenuItem\" was not injected: check your FXML file 'editor.fxml'.";
+        assert saveAllMenuItem != null : "fx:id=\"saveAllMenuItem\" was not injected: check your FXML file 'editor.fxml'.";
+        assert saveAsMenuItem != null : "fx:id=\"saveAsMenuItem\" was not injected: check your FXML file 'editor.fxml'.";
+        assert closeMenuItem != null : "fx:id=\"closeMenuItem\" was not injected: check your FXML file 'editor.fxml'.";
+        assert closeAllMenuItem != null : "fx:id=\"closeAllMenuItem\" was not injected: check your FXML file 'editor.fxml'.";
+        assert editMenu != null : "fx:id=\"editMenu\" was not injected: check your FXML file 'editor.fxml'.";
+        assert runMenu != null : "fx:id=\"runMenu\" was not injected: check your FXML file 'editor.fxml'.";
+        assert autocompile != null : "fx:id=\"autocompile\" was not injected: check your FXML file 'editor.fxml'.";
+        assert tabPane != null : "fx:id=\"tabPane\" was not injected: check your FXML file 'editor.fxml'.";
+        assert statusBar != null : "fx:id=\"statusBar\" was not injected: check your FXML file 'editor.fxml'.";
+
+        tabPane.getTabs().addListener((ListChangeListener.Change<? extends Tab> c) -> {
+            boolean hasNoItems = c.getList().isEmpty();
+            saveMenuItem.setDisable(hasNoItems);
+            saveAsMenuItem.setDisable(hasNoItems);
+            saveAllMenuItem.setDisable(hasNoItems);
+            closeMenuItem.setDisable(hasNoItems);
+            closeAllMenuItem.setDisable(hasNoItems);
+            editMenu.setDisable(hasNoItems);
+            runMenu.setDisable(hasNoItems);
+        });
+    }
+}
diff --git a/src/main/java/jace/ide/LanguageHandler.java b/src/main/java/jace/ide/LanguageHandler.java
new file mode 100644
index 0000000..1fc9dd8
--- /dev/null
+++ b/src/main/java/jace/ide/LanguageHandler.java
@@ -0,0 +1,12 @@
+package jace.ide;
+
+public interface LanguageHandler<T> {
+
+    public String getNewDocumentContent();
+
+    public CompileResult<T> compile(Program program);
+
+    public void execute(CompileResult<T> lastResult);
+    
+    
+}
\ No newline at end of file
diff --git a/src/main/java/jace/ide/Program.java b/src/main/java/jace/ide/Program.java
new file mode 100644
index 0000000..2fa24f0
--- /dev/null
+++ b/src/main/java/jace/ide/Program.java
@@ -0,0 +1,230 @@
+package jace.ide;
+
+import jace.applesoft.ApplesoftHandler;
+import jace.assembly.AssemblyHandler;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javafx.concurrent.Worker;
+import javafx.scene.control.TextInputDialog;
+import javafx.scene.web.PromptData;
+import javafx.scene.web.WebView;
+import netscape.javascript.JSObject;
+
+/**
+ *
+ * @author blurry
+ */
+public class Program {
+
+    public static String CODEMIRROR_EDITOR = "/codemirror/editor.html";
+
+    public void save(File newTarget) {
+        FileWriter writer = null;
+        if (newTarget == null && targetFile == null) {
+            return;
+        }
+        if (newTarget != null) {
+            targetFile = newTarget;
+        }
+        filename = targetFile.getName();
+        try {
+            writer = new FileWriter(targetFile, false);
+            writer.append(getValue());
+            writer.close();
+        } catch (IOException ex) {
+            Logger.getLogger(Program.class.getName()).log(Level.SEVERE, null, ex);
+        } finally {
+            try {
+                if (writer != null) {
+                    writer.close();
+                }
+            } catch (IOException ex) {
+                Logger.getLogger(Program.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        }
+    }
+
+    public boolean isChanged() {
+        return (Boolean) codeMirror.call("isClean");
+    }
+
+    public static enum DocumentType {
+
+        applesoft(new ApplesoftHandler(), "textfile", "*.bas"), assembly(new AssemblyHandler(), "textfile", "*.a", "*.s", "*.asm"), plain(new TextHandler(), "textfile", "*.txt"), hex(new TextHandler(), "textfile", "*.bin", "*.raw");
+
+        static DocumentType fromFile(File file) {
+            String name = file.getName();
+            String ext = name.substring(name.lastIndexOf('.')).toLowerCase();
+            ext = "*" + ext;
+            for (DocumentType type : values()) {
+                if (type.extensions.contains(ext)) {
+                    return type;
+                }
+            }
+            return DocumentType.plain;
+        }
+        String modeName;
+        LanguageHandler languageHandler;
+        List<String> extensions;
+
+        DocumentType(LanguageHandler handler, String mode, String... defaultExtensions) {
+            languageHandler = handler;
+            modeName = mode;
+            extensions = Arrays.asList(defaultExtensions);
+        }
+    }
+
+    public static enum Option {
+
+        mode, value, theme, indentUnit, smartIndent, tabSize, indentWithTabs, electricChars, specialChars,
+        specialCharPlaceHolder, rtlMoveVisually, keyMap, extraKeys, lineWrapping,
+        lineNumbers, firstLineNumber, lineNumberFormatter, gutters, fixedGutter,
+        scrollbarStyle, coverGutterNextToScrollbar, inputStyle, readOnly, showCursorWhenSelecting,
+        lineWiseCopyCut, undoDepth, historyEventDelay, tabindex, autofocus
+    }
+
+    DocumentType fileType;
+    boolean showLineNumbers;
+    Map<Option, Object> options;
+    File targetFile = null;
+    String filename = "Untitled File";
+    JSObject codeMirror;
+    WebView editor;
+    CompileResult lastResult;
+
+    public Program(DocumentType type, Map<Option, Object> globalOptions) {
+        fileType = type;
+        options = new EnumMap<>(Option.class);
+        options.putAll(globalOptions);
+        options.put(Option.mode, fileType.modeName);
+        options.put(Option.lineNumbers, true);
+    }
+
+    public String getName() {
+        return filename;
+    }
+
+    public DocumentType getType() {
+        return fileType;
+    }
+
+    public LanguageHandler getHandler() {
+        return fileType.languageHandler;
+    }
+
+    public String getValue() {
+        return (String) codeMirror.call("getValue");
+    }
+
+    public void setValue(String value) {
+        codeMirror.call("setValue", value);
+    }
+
+    public Optional<File> getFile() {
+        return Optional.ofNullable(targetFile);
+    }
+
+    public void initEditor(WebView editor, File sourceFile) {
+        this.editor = editor;
+        targetFile = sourceFile;
+        if (targetFile != null) {
+            filename = targetFile.getName();
+        }
+
+        editor.getEngine().getLoadWorker().stateProperty().addListener(
+                (value, old, newState) -> {
+                    if (newState == Worker.State.SUCCEEDED) {
+                        JSObject document = (JSObject) editor.getEngine().executeScript("window");
+                        document.setMember("java", this);
+                        createEditor();
+                    }
+                });
+
+        editor.getEngine().setPromptHandler((PromptData prompt) -> {
+            TextInputDialog dialog = new TextInputDialog(prompt.getDefaultValue());
+            dialog.setTitle("Jace IDE");
+            dialog.setHeaderText("Respond and press OK, or Cancel to abort");
+            dialog.setContentText(prompt.getMessage());
+            return dialog.showAndWait().orElse(null);
+        });
+
+        editor.getEngine().load(getClass().getResource(CODEMIRROR_EDITOR).toExternalForm());
+    }
+
+    public void createEditor() {
+        String document = targetFile == null ? getHandler().getNewDocumentContent() : getFileContents(targetFile);
+        String optionString = buildOptions();
+        codeMirror = (JSObject) editor.getEngine().executeScript("CodeMirror(document.body, " + optionString + ");");
+        setValue(document);
+    }
+
+    public String getFileContents(File sourceFile) {
+        if (sourceFile != null && sourceFile.exists() && sourceFile.isFile()) {
+            BufferedReader reader = null;
+            try {
+                StringBuilder input = new StringBuilder();
+                reader = new BufferedReader(new FileReader(sourceFile));
+                reader.lines().forEach((line) -> {
+                    input.append(line);
+                    input.append("\n");
+                });
+                return input.toString();
+            } catch (IOException ex) {
+                Logger.getLogger(Program.class.getName()).log(Level.SEVERE, null, ex);
+            } finally {
+                try {
+                    if (reader != null) {
+                        reader.close();
+                    }
+                } catch (IOException ex) {
+                    Logger.getLogger(Program.class.getName()).log(Level.SEVERE, null, ex);
+                }
+            }
+        }
+        return "";
+    }
+
+    private String buildOptions() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("{");
+        options.forEach((Option o, Object v) -> {
+            if (builder.length() >= 2) {
+                builder.append(",\n");
+            }
+            builder.append(o.name()).append(":");
+            if (v instanceof String) {
+                builder.append('"').append(String.valueOf(v)).append('"');
+            } else {
+                builder.append(String.valueOf(v));
+            }
+        });
+        builder.append("}");
+        return builder.toString();
+    }
+
+    public void execute() {
+        lastResult = getHandler().compile(this);
+        if (lastResult.isSuccessful()) {
+            getHandler().execute(lastResult);
+        }
+    }
+
+    public void test() {
+        lastResult = getHandler().compile(this);
+    }
+
+    public void log(String message) {
+        System.out.println(message);
+    }
+}
diff --git a/src/main/java/jace/ide/TextHandler.java b/src/main/java/jace/ide/TextHandler.java
new file mode 100644
index 0000000..674ecd4
--- /dev/null
+++ b/src/main/java/jace/ide/TextHandler.java
@@ -0,0 +1,55 @@
+package jace.ide;
+
+import jace.core.Keyboard;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * @author blurry
+ */
+class TextHandler implements LanguageHandler<String> {
+    public TextHandler() {
+    }
+
+    @Override
+    public String getNewDocumentContent() {
+        return "\n";
+    }    
+
+    @Override
+    public CompileResult<String> compile(Program program) {
+        return new CompileResult<String>() {
+            @Override
+            public boolean isSuccessful() {
+                return true;
+            }
+
+            @Override
+            public String getCompiledAsset() {
+                return program.getValue();
+            }
+
+            @Override
+            public Map<Integer, String> getErrorsAndWarnings() {
+                return Collections.EMPTY_MAP;
+            }
+
+            @Override
+            public List<String> getOtherMessages() {
+                return Collections.EMPTY_LIST;
+            }
+
+            @Override
+            public List<String> getRawOutput() {
+                return Collections.EMPTY_LIST;
+            }
+        };
+    }
+
+    @Override
+    public void execute(CompileResult<String> lastResult) {
+        Keyboard.pasteFromString(lastResult.getCompiledAsset());
+    }
+}
diff --git a/src/main/resources/codemirror/addon/comment/comment.js b/src/main/resources/codemirror/addon/comment/comment.js
new file mode 100755
index 0000000..2dd114d
--- /dev/null
+++ b/src/main/resources/codemirror/addon/comment/comment.js
@@ -0,0 +1,183 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var noOptions = {};
+  var nonWS = /[^\s\u00a0]/;
+  var Pos = CodeMirror.Pos;
+
+  function firstNonWS(str) {
+    var found = str.search(nonWS);
+    return found == -1 ? 0 : found;
+  }
+
+  CodeMirror.commands.toggleComment = function(cm) {
+    var minLine = Infinity, ranges = cm.listSelections(), mode = null;
+    for (var i = ranges.length - 1; i >= 0; i--) {
+      var from = ranges[i].from(), to = ranges[i].to();
+      if (from.line >= minLine) continue;
+      if (to.line >= minLine) to = Pos(minLine, 0);
+      minLine = from.line;
+      if (mode == null) {
+        if (cm.uncomment(from, to)) mode = "un";
+        else { cm.lineComment(from, to); mode = "line"; }
+      } else if (mode == "un") {
+        cm.uncomment(from, to);
+      } else {
+        cm.lineComment(from, to);
+      }
+    }
+  };
+
+  CodeMirror.defineExtension("lineComment", function(from, to, options) {
+    if (!options) options = noOptions;
+    var self = this, mode = self.getModeAt(from);
+    var commentString = options.lineComment || mode.lineComment;
+    if (!commentString) {
+      if (options.blockCommentStart || mode.blockCommentStart) {
+        options.fullLines = true;
+        self.blockComment(from, to, options);
+      }
+      return;
+    }
+    var firstLine = self.getLine(from.line);
+    if (firstLine == null) return;
+    var end = Math.min(to.ch != 0 || to.line == from.line ? to.line + 1 : to.line, self.lastLine() + 1);
+    var pad = options.padding == null ? " " : options.padding;
+    var blankLines = options.commentBlankLines || from.line == to.line;
+
+    self.operation(function() {
+      if (options.indent) {
+        var baseString = firstLine.slice(0, firstNonWS(firstLine));
+        for (var i = from.line; i < end; ++i) {
+          var line = self.getLine(i), cut = baseString.length;
+          if (!blankLines && !nonWS.test(line)) continue;
+          if (line.slice(0, cut) != baseString) cut = firstNonWS(line);
+          self.replaceRange(baseString + commentString + pad, Pos(i, 0), Pos(i, cut));
+        }
+      } else {
+        for (var i = from.line; i < end; ++i) {
+          if (blankLines || nonWS.test(self.getLine(i)))
+            self.replaceRange(commentString + pad, Pos(i, 0));
+        }
+      }
+    });
+  });
+
+  CodeMirror.defineExtension("blockComment", function(from, to, options) {
+    if (!options) options = noOptions;
+    var self = this, mode = self.getModeAt(from);
+    var startString = options.blockCommentStart || mode.blockCommentStart;
+    var endString = options.blockCommentEnd || mode.blockCommentEnd;
+    if (!startString || !endString) {
+      if ((options.lineComment || mode.lineComment) && options.fullLines != false)
+        self.lineComment(from, to, options);
+      return;
+    }
+
+    var end = Math.min(to.line, self.lastLine());
+    if (end != from.line && to.ch == 0 && nonWS.test(self.getLine(end))) --end;
+
+    var pad = options.padding == null ? " " : options.padding;
+    if (from.line > end) return;
+
+    self.operation(function() {
+      if (options.fullLines != false) {
+        var lastLineHasText = nonWS.test(self.getLine(end));
+        self.replaceRange(pad + endString, Pos(end));
+        self.replaceRange(startString + pad, Pos(from.line, 0));
+        var lead = options.blockCommentLead || mode.blockCommentLead;
+        if (lead != null) for (var i = from.line + 1; i <= end; ++i)
+          if (i != end || lastLineHasText)
+            self.replaceRange(lead + pad, Pos(i, 0));
+      } else {
+        self.replaceRange(endString, to);
+        self.replaceRange(startString, from);
+      }
+    });
+  });
+
+  CodeMirror.defineExtension("uncomment", function(from, to, options) {
+    if (!options) options = noOptions;
+    var self = this, mode = self.getModeAt(from);
+    var end = Math.min(to.ch != 0 || to.line == from.line ? to.line : to.line - 1, self.lastLine()), start = Math.min(from.line, end);
+
+    // Try finding line comments
+    var lineString = options.lineComment || mode.lineComment, lines = [];
+    var pad = options.padding == null ? " " : options.padding, didSomething;
+    lineComment: {
+      if (!lineString) break lineComment;
+      for (var i = start; i <= end; ++i) {
+        var line = self.getLine(i);
+        var found = line.indexOf(lineString);
+        if (found > -1 && !/comment/.test(self.getTokenTypeAt(Pos(i, found + 1)))) found = -1;
+        if (found == -1 && (i != end || i == start) && nonWS.test(line)) break lineComment;
+        if (found > -1 && nonWS.test(line.slice(0, found))) break lineComment;
+        lines.push(line);
+      }
+      self.operation(function() {
+        for (var i = start; i <= end; ++i) {
+          var line = lines[i - start];
+          var pos = line.indexOf(lineString), endPos = pos + lineString.length;
+          if (pos < 0) continue;
+          if (line.slice(endPos, endPos + pad.length) == pad) endPos += pad.length;
+          didSomething = true;
+          self.replaceRange("", Pos(i, pos), Pos(i, endPos));
+        }
+      });
+      if (didSomething) return true;
+    }
+
+    // Try block comments
+    var startString = options.blockCommentStart || mode.blockCommentStart;
+    var endString = options.blockCommentEnd || mode.blockCommentEnd;
+    if (!startString || !endString) return false;
+    var lead = options.blockCommentLead || mode.blockCommentLead;
+    var startLine = self.getLine(start), endLine = end == start ? startLine : self.getLine(end);
+    var open = startLine.indexOf(startString), close = endLine.lastIndexOf(endString);
+    if (close == -1 && start != end) {
+      endLine = self.getLine(--end);
+      close = endLine.lastIndexOf(endString);
+    }
+    if (open == -1 || close == -1 ||
+        !/comment/.test(self.getTokenTypeAt(Pos(start, open + 1))) ||
+        !/comment/.test(self.getTokenTypeAt(Pos(end, close + 1))))
+      return false;
+
+    // Avoid killing block comments completely outside the selection.
+    // Positions of the last startString before the start of the selection, and the first endString after it.
+    var lastStart = startLine.lastIndexOf(startString, from.ch);
+    var firstEnd = lastStart == -1 ? -1 : startLine.slice(0, from.ch).indexOf(endString, lastStart + startString.length);
+    if (lastStart != -1 && firstEnd != -1 && firstEnd + endString.length != from.ch) return false;
+    // Positions of the first endString after the end of the selection, and the last startString before it.
+    firstEnd = endLine.indexOf(endString, to.ch);
+    var almostLastStart = endLine.slice(to.ch).lastIndexOf(startString, firstEnd - to.ch);
+    lastStart = (firstEnd == -1 || almostLastStart == -1) ? -1 : to.ch + almostLastStart;
+    if (firstEnd != -1 && lastStart != -1 && lastStart != to.ch) return false;
+
+    self.operation(function() {
+      self.replaceRange("", Pos(end, close - (pad && endLine.slice(close - pad.length, close) == pad ? pad.length : 0)),
+                        Pos(end, close + endString.length));
+      var openEnd = open + startString.length;
+      if (pad && startLine.slice(openEnd, openEnd + pad.length) == pad) openEnd += pad.length;
+      self.replaceRange("", Pos(start, open), Pos(start, openEnd));
+      if (lead) for (var i = start + 1; i <= end; ++i) {
+        var line = self.getLine(i), found = line.indexOf(lead);
+        if (found == -1 || nonWS.test(line.slice(0, found))) continue;
+        var foundEnd = found + lead.length;
+        if (pad && line.slice(foundEnd, foundEnd + pad.length) == pad) foundEnd += pad.length;
+        self.replaceRange("", Pos(i, found), Pos(i, foundEnd));
+      }
+    });
+    return true;
+  });
+});
diff --git a/src/main/resources/codemirror/addon/comment/continuecomment.js b/src/main/resources/codemirror/addon/comment/continuecomment.js
new file mode 100755
index 0000000..b11d51e
--- /dev/null
+++ b/src/main/resources/codemirror/addon/comment/continuecomment.js
@@ -0,0 +1,85 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  var modes = ["clike", "css", "javascript"];
+
+  for (var i = 0; i < modes.length; ++i)
+    CodeMirror.extendMode(modes[i], {blockCommentContinue: " * "});
+
+  function continueComment(cm) {
+    if (cm.getOption("disableInput")) return CodeMirror.Pass;
+    var ranges = cm.listSelections(), mode, inserts = [];
+    for (var i = 0; i < ranges.length; i++) {
+      var pos = ranges[i].head, token = cm.getTokenAt(pos);
+      if (token.type != "comment") return CodeMirror.Pass;
+      var modeHere = CodeMirror.innerMode(cm.getMode(), token.state).mode;
+      if (!mode) mode = modeHere;
+      else if (mode != modeHere) return CodeMirror.Pass;
+
+      var insert = null;
+      if (mode.blockCommentStart && mode.blockCommentContinue) {
+        var end = token.string.indexOf(mode.blockCommentEnd);
+        var full = cm.getRange(CodeMirror.Pos(pos.line, 0), CodeMirror.Pos(pos.line, token.end)), found;
+        if (end != -1 && end == token.string.length - mode.blockCommentEnd.length && pos.ch >= end) {
+          // Comment ended, don't continue it
+        } else if (token.string.indexOf(mode.blockCommentStart) == 0) {
+          insert = full.slice(0, token.start);
+          if (!/^\s*$/.test(insert)) {
+            insert = "";
+            for (var j = 0; j < token.start; ++j) insert += " ";
+          }
+        } else if ((found = full.indexOf(mode.blockCommentContinue)) != -1 &&
+                   found + mode.blockCommentContinue.length > token.start &&
+                   /^\s*$/.test(full.slice(0, found))) {
+          insert = full.slice(0, found);
+        }
+        if (insert != null) insert += mode.blockCommentContinue;
+      }
+      if (insert == null && mode.lineComment && continueLineCommentEnabled(cm)) {
+        var line = cm.getLine(pos.line), found = line.indexOf(mode.lineComment);
+        if (found > -1) {
+          insert = line.slice(0, found);
+          if (/\S/.test(insert)) insert = null;
+          else insert += mode.lineComment + line.slice(found + mode.lineComment.length).match(/^\s*/)[0];
+        }
+      }
+      if (insert == null) return CodeMirror.Pass;
+      inserts[i] = "\n" + insert;
+    }
+
+    cm.operation(function() {
+      for (var i = ranges.length - 1; i >= 0; i--)
+        cm.replaceRange(inserts[i], ranges[i].from(), ranges[i].to(), "+insert");
+    });
+  }
+
+  function continueLineCommentEnabled(cm) {
+    var opt = cm.getOption("continueComments");
+    if (opt && typeof opt == "object")
+      return opt.continueLineComment !== false;
+    return true;
+  }
+
+  CodeMirror.defineOption("continueComments", null, function(cm, val, prev) {
+    if (prev && prev != CodeMirror.Init)
+      cm.removeKeyMap("continueComment");
+    if (val) {
+      var key = "Enter";
+      if (typeof val == "string")
+        key = val;
+      else if (typeof val == "object" && val.key)
+        key = val.key;
+      var map = {name: "continueComment"};
+      map[key] = continueComment;
+      cm.addKeyMap(map);
+    }
+  });
+});
diff --git a/src/main/resources/codemirror/addon/dialog/dialog.css b/src/main/resources/codemirror/addon/dialog/dialog.css
new file mode 100755
index 0000000..677c078
--- /dev/null
+++ b/src/main/resources/codemirror/addon/dialog/dialog.css
@@ -0,0 +1,32 @@
+.CodeMirror-dialog {
+  position: absolute;
+  left: 0; right: 0;
+  background: inherit;
+  z-index: 15;
+  padding: .1em .8em;
+  overflow: hidden;
+  color: inherit;
+}
+
+.CodeMirror-dialog-top {
+  border-bottom: 1px solid #eee;
+  top: 0;
+}
+
+.CodeMirror-dialog-bottom {
+  border-top: 1px solid #eee;
+  bottom: 0;
+}
+
+.CodeMirror-dialog input {
+  border: none;
+  outline: none;
+  background: transparent;
+  width: 20em;
+  color: inherit;
+  font-family: monospace;
+}
+
+.CodeMirror-dialog button {
+  font-size: 70%;
+}
diff --git a/src/main/resources/codemirror/addon/dialog/dialog.js b/src/main/resources/codemirror/addon/dialog/dialog.js
new file mode 100755
index 0000000..323b200
--- /dev/null
+++ b/src/main/resources/codemirror/addon/dialog/dialog.js
@@ -0,0 +1,157 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Open simple dialogs on top of an editor. Relies on dialog.css.
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  function dialogDiv(cm, template, bottom) {
+    var wrap = cm.getWrapperElement();
+    var dialog;
+    dialog = wrap.appendChild(document.createElement("div"));
+    if (bottom)
+      dialog.className = "CodeMirror-dialog CodeMirror-dialog-bottom";
+    else
+      dialog.className = "CodeMirror-dialog CodeMirror-dialog-top";
+
+    if (typeof template == "string") {
+      dialog.innerHTML = template;
+    } else { // Assuming it's a detached DOM element.
+      dialog.appendChild(template);
+    }
+    return dialog;
+  }
+
+  function closeNotification(cm, newVal) {
+    if (cm.state.currentNotificationClose)
+      cm.state.currentNotificationClose();
+    cm.state.currentNotificationClose = newVal;
+  }
+
+  CodeMirror.defineExtension("openDialog", function(template, callback, options) {
+    if (!options) options = {};
+
+    closeNotification(this, null);
+
+    var dialog = dialogDiv(this, template, options.bottom);
+    var closed = false, me = this;
+    function close(newVal) {
+      if (typeof newVal == 'string') {
+        inp.value = newVal;
+      } else {
+        if (closed) return;
+        closed = true;
+        dialog.parentNode.removeChild(dialog);
+        me.focus();
+
+        if (options.onClose) options.onClose(dialog);
+      }
+    }
+
+    var inp = dialog.getElementsByTagName("input")[0], button;
+    if (inp) {
+      if (options.value) {
+        inp.value = options.value;
+        if (options.selectValueOnOpen !== false) {
+          inp.select();
+        }
+      }
+
+      if (options.onInput)
+        CodeMirror.on(inp, "input", function(e) { options.onInput(e, inp.value, close);});
+      if (options.onKeyUp)
+        CodeMirror.on(inp, "keyup", function(e) {options.onKeyUp(e, inp.value, close);});
+
+      CodeMirror.on(inp, "keydown", function(e) {
+        if (options && options.onKeyDown && options.onKeyDown(e, inp.value, close)) { return; }
+        if (e.keyCode == 27 || (options.closeOnEnter !== false && e.keyCode == 13)) {
+          inp.blur();
+          CodeMirror.e_stop(e);
+          close();
+        }
+        if (e.keyCode == 13) callback(inp.value, e);
+      });
+
+      if (options.closeOnBlur !== false) CodeMirror.on(inp, "blur", close);
+
+      inp.focus();
+    } else if (button = dialog.getElementsByTagName("button")[0]) {
+      CodeMirror.on(button, "click", function() {
+        close();
+        me.focus();
+      });
+
+      if (options.closeOnBlur !== false) CodeMirror.on(button, "blur", close);
+
+      button.focus();
+    }
+    return close;
+  });
+
+  CodeMirror.defineExtension("openConfirm", function(template, callbacks, options) {
+    closeNotification(this, null);
+    var dialog = dialogDiv(this, template, options && options.bottom);
+    var buttons = dialog.getElementsByTagName("button");
+    var closed = false, me = this, blurring = 1;
+    function close() {
+      if (closed) return;
+      closed = true;
+      dialog.parentNode.removeChild(dialog);
+      me.focus();
+    }
+    buttons[0].focus();
+    for (var i = 0; i < buttons.length; ++i) {
+      var b = buttons[i];
+      (function(callback) {
+        CodeMirror.on(b, "click", function(e) {
+          CodeMirror.e_preventDefault(e);
+          close();
+          if (callback) callback(me);
+        });
+      })(callbacks[i]);
+      CodeMirror.on(b, "blur", function() {
+        --blurring;
+        setTimeout(function() { if (blurring <= 0) close(); }, 200);
+      });
+      CodeMirror.on(b, "focus", function() { ++blurring; });
+    }
+  });
+
+  /*
+   * openNotification
+   * Opens a notification, that can be closed with an optional timer
+   * (default 5000ms timer) and always closes on click.
+   *
+   * If a notification is opened while another is opened, it will close the
+   * currently opened one and open the new one immediately.
+   */
+  CodeMirror.defineExtension("openNotification", function(template, options) {
+    closeNotification(this, close);
+    var dialog = dialogDiv(this, template, options && options.bottom);
+    var closed = false, doneTimer;
+    var duration = options && typeof options.duration !== "undefined" ? options.duration : 5000;
+
+    function close() {
+      if (closed) return;
+      closed = true;
+      clearTimeout(doneTimer);
+      dialog.parentNode.removeChild(dialog);
+    }
+
+    CodeMirror.on(dialog, 'click', function(e) {
+      CodeMirror.e_preventDefault(e);
+      close();
+    });
+
+    if (duration)
+      doneTimer = setTimeout(close, duration);
+
+    return close;
+  });
+});
diff --git a/src/main/resources/codemirror/addon/display/fullscreen.css b/src/main/resources/codemirror/addon/display/fullscreen.css
new file mode 100755
index 0000000..437acd8
--- /dev/null
+++ b/src/main/resources/codemirror/addon/display/fullscreen.css
@@ -0,0 +1,6 @@
+.CodeMirror-fullscreen {
+  position: fixed;
+  top: 0; left: 0; right: 0; bottom: 0;
+  height: auto;
+  z-index: 9;
+}
diff --git a/src/main/resources/codemirror/addon/display/fullscreen.js b/src/main/resources/codemirror/addon/display/fullscreen.js
new file mode 100755
index 0000000..cd3673b
--- /dev/null
+++ b/src/main/resources/codemirror/addon/display/fullscreen.js
@@ -0,0 +1,41 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineOption("fullScreen", false, function(cm, val, old) {
+    if (old == CodeMirror.Init) old = false;
+    if (!old == !val) return;
+    if (val) setFullscreen(cm);
+    else setNormal(cm);
+  });
+
+  function setFullscreen(cm) {
+    var wrap = cm.getWrapperElement();
+    cm.state.fullScreenRestore = {scrollTop: window.pageYOffset, scrollLeft: window.pageXOffset,
+                                  width: wrap.style.width, height: wrap.style.height};
+    wrap.style.width = "";
+    wrap.style.height = "auto";
+    wrap.className += " CodeMirror-fullscreen";
+    document.documentElement.style.overflow = "hidden";
+    cm.refresh();
+  }
+
+  function setNormal(cm) {
+    var wrap = cm.getWrapperElement();
+    wrap.className = wrap.className.replace(/\s*CodeMirror-fullscreen\b/, "");
+    document.documentElement.style.overflow = "";
+    var info = cm.state.fullScreenRestore;
+    wrap.style.width = info.width; wrap.style.height = info.height;
+    window.scrollTo(info.scrollLeft, info.scrollTop);
+    cm.refresh();
+  }
+});
diff --git a/src/main/resources/codemirror/addon/display/panel.js b/src/main/resources/codemirror/addon/display/panel.js
new file mode 100755
index 0000000..ba29484
--- /dev/null
+++ b/src/main/resources/codemirror/addon/display/panel.js
@@ -0,0 +1,112 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  CodeMirror.defineExtension("addPanel", function(node, options) {
+    options = options || {};
+
+    if (!this.state.panels) initPanels(this);
+
+    var info = this.state.panels;
+    var wrapper = info.wrapper;
+    var cmWrapper = this.getWrapperElement();
+
+    if (options.after instanceof Panel && !options.after.cleared) {
+      wrapper.insertBefore(node, options.before.node.nextSibling);
+    } else if (options.before instanceof Panel && !options.before.cleared) {
+      wrapper.insertBefore(node, options.before.node);
+    } else if (options.replace instanceof Panel && !options.replace.cleared) {
+      wrapper.insertBefore(node, options.replace.node);
+      options.replace.clear();
+    } else if (options.position == "bottom") {
+      wrapper.appendChild(node);
+    } else if (options.position == "before-bottom") {
+      wrapper.insertBefore(node, cmWrapper.nextSibling);
+    } else if (options.position == "after-top") {
+      wrapper.insertBefore(node, cmWrapper);
+    } else {
+      wrapper.insertBefore(node, wrapper.firstChild);
+    }
+
+    var height = (options && options.height) || node.offsetHeight;
+    this._setSize(null, info.heightLeft -= height);
+    info.panels++;
+    return new Panel(this, node, options, height);
+  });
+
+  function Panel(cm, node, options, height) {
+    this.cm = cm;
+    this.node = node;
+    this.options = options;
+    this.height = height;
+    this.cleared = false;
+  }
+
+  Panel.prototype.clear = function() {
+    if (this.cleared) return;
+    this.cleared = true;
+    var info = this.cm.state.panels;
+    this.cm._setSize(null, info.heightLeft += this.height);
+    info.wrapper.removeChild(this.node);
+    if (--info.panels == 0) removePanels(this.cm);
+  };
+
+  Panel.prototype.changed = function(height) {
+    var newHeight = height == null ? this.node.offsetHeight : height;
+    var info = this.cm.state.panels;
+    this.cm._setSize(null, info.height += (newHeight - this.height));
+    this.height = newHeight;
+  };
+
+  function initPanels(cm) {
+    var wrap = cm.getWrapperElement();
+    var style = window.getComputedStyle ? window.getComputedStyle(wrap) : wrap.currentStyle;
+    var height = parseInt(style.height);
+    var info = cm.state.panels = {
+      setHeight: wrap.style.height,
+      heightLeft: height,
+      panels: 0,
+      wrapper: document.createElement("div")
+    };
+    wrap.parentNode.insertBefore(info.wrapper, wrap);
+    var hasFocus = cm.hasFocus();
+    info.wrapper.appendChild(wrap);
+    if (hasFocus) cm.focus();
+
+    cm._setSize = cm.setSize;
+    if (height != null) cm.setSize = function(width, newHeight) {
+      if (newHeight == null) return this._setSize(width, newHeight);
+      info.setHeight = newHeight;
+      if (typeof newHeight != "number") {
+        var px = /^(\d+\.?\d*)px$/.exec(newHeight);
+        if (px) {
+          newHeight = Number(px[1]);
+        } else {
+          info.wrapper.style.height = newHeight;
+          newHeight = info.wrapper.offsetHeight;
+          info.wrapper.style.height = "";
+        }
+      }
+      cm._setSize(width, info.heightLeft += (newHeight - height));
+      height = newHeight;
+    };
+  }
+
+  function removePanels(cm) {
+    var info = cm.state.panels;
+    cm.state.panels = null;
+
+    var wrap = cm.getWrapperElement();
+    info.wrapper.parentNode.replaceChild(wrap, info.wrapper);
+    wrap.style.height = info.setHeight;
+    cm.setSize = cm._setSize;
+    cm.setSize();
+  }
+});
diff --git a/src/main/resources/codemirror/addon/display/placeholder.js b/src/main/resources/codemirror/addon/display/placeholder.js
new file mode 100755
index 0000000..bb0c393
--- /dev/null
+++ b/src/main/resources/codemirror/addon/display/placeholder.js
@@ -0,0 +1,58 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  CodeMirror.defineOption("placeholder", "", function(cm, val, old) {
+    var prev = old && old != CodeMirror.Init;
+    if (val && !prev) {
+      cm.on("blur", onBlur);
+      cm.on("change", onChange);
+      onChange(cm);
+    } else if (!val && prev) {
+      cm.off("blur", onBlur);
+      cm.off("change", onChange);
+      clearPlaceholder(cm);
+      var wrapper = cm.getWrapperElement();
+      wrapper.className = wrapper.className.replace(" CodeMirror-empty", "");
+    }
+
+    if (val && !cm.hasFocus()) onBlur(cm);
+  });
+
+  function clearPlaceholder(cm) {
+    if (cm.state.placeholder) {
+      cm.state.placeholder.parentNode.removeChild(cm.state.placeholder);
+      cm.state.placeholder = null;
+    }
+  }
+  function setPlaceholder(cm) {
+    clearPlaceholder(cm);
+    var elt = cm.state.placeholder = document.createElement("pre");
+    elt.style.cssText = "height: 0; overflow: visible";
+    elt.className = "CodeMirror-placeholder";
+    elt.appendChild(document.createTextNode(cm.getOption("placeholder")));
+    cm.display.lineSpace.insertBefore(elt, cm.display.lineSpace.firstChild);
+  }
+
+  function onBlur(cm) {
+    if (isEmpty(cm)) setPlaceholder(cm);
+  }
+  function onChange(cm) {
+    var wrapper = cm.getWrapperElement(), empty = isEmpty(cm);
+    wrapper.className = wrapper.className.replace(" CodeMirror-empty", "") + (empty ? " CodeMirror-empty" : "");
+
+    if (empty) setPlaceholder(cm);
+    else clearPlaceholder(cm);
+  }
+
+  function isEmpty(cm) {
+    return (cm.lineCount() === 1) && (cm.getLine(0) === "");
+  }
+});
diff --git a/src/main/resources/codemirror/addon/display/rulers.js b/src/main/resources/codemirror/addon/display/rulers.js
new file mode 100755
index 0000000..01f6566
--- /dev/null
+++ b/src/main/resources/codemirror/addon/display/rulers.js
@@ -0,0 +1,63 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineOption("rulers", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      clearRulers(cm);
+      cm.off("refresh", refreshRulers);
+    }
+    if (val && val.length) {
+      setRulers(cm);
+      cm.on("refresh", refreshRulers);
+    }
+  });
+
+  function clearRulers(cm) {
+    for (var i = cm.display.lineSpace.childNodes.length - 1; i >= 0; i--) {
+      var node = cm.display.lineSpace.childNodes[i];
+      if (/(^|\s)CodeMirror-ruler($|\s)/.test(node.className))
+        node.parentNode.removeChild(node);
+    }
+  }
+
+  function setRulers(cm) {
+    var val = cm.getOption("rulers");
+    var cw = cm.defaultCharWidth();
+    var left = cm.charCoords(CodeMirror.Pos(cm.firstLine(), 0), "div").left;
+    var minH = cm.display.scroller.offsetHeight + 30;
+    for (var i = 0; i < val.length; i++) {
+      var elt = document.createElement("div");
+      elt.className = "CodeMirror-ruler";
+      var col, conf = val[i];
+      if (typeof conf == "number") {
+        col = conf;
+      } else {
+        col = conf.column;
+        if (conf.className) elt.className += " " + conf.className;
+        if (conf.color) elt.style.borderColor = conf.color;
+        if (conf.lineStyle) elt.style.borderLeftStyle = conf.lineStyle;
+        if (conf.width) elt.style.borderLeftWidth = conf.width;
+      }
+      elt.style.left = (left + col * cw) + "px";
+      elt.style.top = "-50px";
+      elt.style.bottom = "-20px";
+      elt.style.minHeight = minH + "px";
+      cm.display.lineSpace.insertBefore(elt, cm.display.cursorDiv);
+    }
+  }
+
+  function refreshRulers(cm) {
+    clearRulers(cm);
+    setRulers(cm);
+  }
+});
diff --git a/src/main/resources/codemirror/addon/edit/closebrackets.js b/src/main/resources/codemirror/addon/edit/closebrackets.js
new file mode 100755
index 0000000..7030268
--- /dev/null
+++ b/src/main/resources/codemirror/addon/edit/closebrackets.js
@@ -0,0 +1,185 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  var defaults = {
+    pairs: "()[]{}''\"\"",
+    triples: "",
+    explode: "[]{}"
+  };
+
+  var Pos = CodeMirror.Pos;
+
+  CodeMirror.defineOption("autoCloseBrackets", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      cm.removeKeyMap(keyMap);
+      cm.state.closeBrackets = null;
+    }
+    if (val) {
+      cm.state.closeBrackets = val;
+      cm.addKeyMap(keyMap);
+    }
+  });
+
+  function getOption(conf, name) {
+    if (name == "pairs" && typeof conf == "string") return conf;
+    if (typeof conf == "object" && conf[name] != null) return conf[name];
+    return defaults[name];
+  }
+
+  var bind = defaults.pairs + "`";
+  var keyMap = {Backspace: handleBackspace, Enter: handleEnter};
+  for (var i = 0; i < bind.length; i++)
+    keyMap["'" + bind.charAt(i) + "'"] = handler(bind.charAt(i));
+
+  function handler(ch) {
+    return function(cm) { return handleChar(cm, ch); };
+  }
+
+  function getConfig(cm) {
+    var deflt = cm.state.closeBrackets;
+    if (!deflt) return null;
+    var mode = cm.getModeAt(cm.getCursor());
+    return mode.closeBrackets || deflt;
+  }
+
+  function handleBackspace(cm) {
+    var conf = getConfig(cm);
+    if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+    var pairs = getOption(conf, "pairs");
+    var ranges = cm.listSelections();
+    for (var i = 0; i < ranges.length; i++) {
+      if (!ranges[i].empty()) return CodeMirror.Pass;
+      var around = charsAround(cm, ranges[i].head);
+      if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;
+    }
+    for (var i = ranges.length - 1; i >= 0; i--) {
+      var cur = ranges[i].head;
+      cm.replaceRange("", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1));
+    }
+  }
+
+  function handleEnter(cm) {
+    var conf = getConfig(cm);
+    var explode = conf && getOption(conf, "explode");
+    if (!explode || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+    var ranges = cm.listSelections();
+    for (var i = 0; i < ranges.length; i++) {
+      if (!ranges[i].empty()) return CodeMirror.Pass;
+      var around = charsAround(cm, ranges[i].head);
+      if (!around || explode.indexOf(around) % 2 != 0) return CodeMirror.Pass;
+    }
+    cm.operation(function() {
+      cm.replaceSelection("\n\n", null);
+      cm.execCommand("goCharLeft");
+      ranges = cm.listSelections();
+      for (var i = 0; i < ranges.length; i++) {
+        var line = ranges[i].head.line;
+        cm.indentLine(line, null, true);
+        cm.indentLine(line + 1, null, true);
+      }
+    });
+  }
+
+  function handleChar(cm, ch) {
+    var conf = getConfig(cm);
+    if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+    var pairs = getOption(conf, "pairs");
+    var pos = pairs.indexOf(ch);
+    if (pos == -1) return CodeMirror.Pass;
+    var triples = getOption(conf, "triples");
+
+    var identical = pairs.charAt(pos + 1) == ch;
+    var ranges = cm.listSelections();
+    var opening = pos % 2 == 0;
+
+    var type, next;
+    for (var i = 0; i < ranges.length; i++) {
+      var range = ranges[i], cur = range.head, curType;
+      var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));
+      if (opening && !range.empty()) {
+        curType = "surround";
+      } else if ((identical || !opening) && next == ch) {
+        if (triples.indexOf(ch) >= 0 && cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch + ch + ch)
+          curType = "skipThree";
+        else
+          curType = "skip";
+      } else if (identical && cur.ch > 1 && triples.indexOf(ch) >= 0 &&
+                 cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch + ch &&
+                 (cur.ch <= 2 || cm.getRange(Pos(cur.line, cur.ch - 3), Pos(cur.line, cur.ch - 2)) != ch)) {
+        curType = "addFour";
+      } else if (identical) {
+        if (!CodeMirror.isWordChar(next) && enteringString(cm, cur, ch)) curType = "both";
+        else return CodeMirror.Pass;
+      } else if (opening && (cm.getLine(cur.line).length == cur.ch ||
+                             isClosingBracket(next, pairs) ||
+                             /\s/.test(next))) {
+        curType = "both";
+      } else {
+        return CodeMirror.Pass;
+      }
+      if (!type) type = curType;
+      else if (type != curType) return CodeMirror.Pass;
+    }
+
+    var left = pos % 2 ? pairs.charAt(pos - 1) : ch;
+    var right = pos % 2 ? ch : pairs.charAt(pos + 1);
+    cm.operation(function() {
+      if (type == "skip") {
+        cm.execCommand("goCharRight");
+      } else if (type == "skipThree") {
+        for (var i = 0; i < 3; i++)
+          cm.execCommand("goCharRight");
+      } else if (type == "surround") {
+        var sels = cm.getSelections();
+        for (var i = 0; i < sels.length; i++)
+          sels[i] = left + sels[i] + right;
+        cm.replaceSelections(sels, "around");
+      } else if (type == "both") {
+        cm.replaceSelection(left + right, null);
+        cm.triggerElectric(left + right);
+        cm.execCommand("goCharLeft");
+      } else if (type == "addFour") {
+        cm.replaceSelection(left + left + left + left, "before");
+        cm.execCommand("goCharRight");
+      }
+    });
+  }
+
+  function isClosingBracket(ch, pairs) {
+    var pos = pairs.lastIndexOf(ch);
+    return pos > -1 && pos % 2 == 1;
+  }
+
+  function charsAround(cm, pos) {
+    var str = cm.getRange(Pos(pos.line, pos.ch - 1),
+                          Pos(pos.line, pos.ch + 1));
+    return str.length == 2 ? str : null;
+  }
+
+  // Project the token type that will exists after the given char is
+  // typed, and use it to determine whether it would cause the start
+  // of a string token.
+  function enteringString(cm, pos, ch) {
+    var line = cm.getLine(pos.line);
+    var token = cm.getTokenAt(pos);
+    if (/\bstring2?\b/.test(token.type)) return false;
+    var stream = new CodeMirror.StringStream(line.slice(0, pos.ch) + ch + line.slice(pos.ch), 4);
+    stream.pos = stream.start = token.start;
+    for (;;) {
+      var type1 = cm.getMode().token(stream, token.state);
+      if (stream.pos >= pos.ch + 1) return /\bstring2?\b/.test(type1);
+      stream.start = stream.pos;
+    }
+  }
+});
diff --git a/src/main/resources/codemirror/addon/edit/closetag.js b/src/main/resources/codemirror/addon/edit/closetag.js
new file mode 100755
index 0000000..e68d52d
--- /dev/null
+++ b/src/main/resources/codemirror/addon/edit/closetag.js
@@ -0,0 +1,166 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+/**
+ * Tag-closer extension for CodeMirror.
+ *
+ * This extension adds an "autoCloseTags" option that can be set to
+ * either true to get the default behavior, or an object to further
+ * configure its behavior.
+ *
+ * These are supported options:
+ *
+ * `whenClosing` (default true)
+ *   Whether to autoclose when the '/' of a closing tag is typed.
+ * `whenOpening` (default true)
+ *   Whether to autoclose the tag when the final '>' of an opening
+ *   tag is typed.
+ * `dontCloseTags` (default is empty tags for HTML, none for XML)
+ *   An array of tag names that should not be autoclosed.
+ * `indentTags` (default is block tags for HTML, none for XML)
+ *   An array of tag names that should, when opened, cause a
+ *   blank line to be added inside the tag, and the blank line and
+ *   closing line to be indented.
+ *
+ * See demos/closetag.html for a usage example.
+ */
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("../fold/xml-fold"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "../fold/xml-fold"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  CodeMirror.defineOption("autoCloseTags", false, function(cm, val, old) {
+    if (old != CodeMirror.Init && old)
+      cm.removeKeyMap("autoCloseTags");
+    if (!val) return;
+    var map = {name: "autoCloseTags"};
+    if (typeof val != "object" || val.whenClosing)
+      map["'/'"] = function(cm) { return autoCloseSlash(cm); };
+    if (typeof val != "object" || val.whenOpening)
+      map["'>'"] = function(cm) { return autoCloseGT(cm); };
+    cm.addKeyMap(map);
+  });
+
+  var htmlDontClose = ["area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param",
+                       "source", "track", "wbr"];
+  var htmlIndent = ["applet", "blockquote", "body", "button", "div", "dl", "fieldset", "form", "frameset", "h1", "h2", "h3", "h4",
+                    "h5", "h6", "head", "html", "iframe", "layer", "legend", "object", "ol", "p", "select", "table", "ul"];
+
+  function autoCloseGT(cm) {
+    if (cm.getOption("disableInput")) return CodeMirror.Pass;
+    var ranges = cm.listSelections(), replacements = [];
+    for (var i = 0; i < ranges.length; i++) {
+      if (!ranges[i].empty()) return CodeMirror.Pass;
+      var pos = ranges[i].head, tok = cm.getTokenAt(pos);
+      var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state;
+      if (inner.mode.name != "xml" || !state.tagName) return CodeMirror.Pass;
+
+      var opt = cm.getOption("autoCloseTags"), html = inner.mode.configuration == "html";
+      var dontCloseTags = (typeof opt == "object" && opt.dontCloseTags) || (html && htmlDontClose);
+      var indentTags = (typeof opt == "object" && opt.indentTags) || (html && htmlIndent);
+
+      var tagName = state.tagName;
+      if (tok.end > pos.ch) tagName = tagName.slice(0, tagName.length - tok.end + pos.ch);
+      var lowerTagName = tagName.toLowerCase();
+      // Don't process the '>' at the end of an end-tag or self-closing tag
+      if (!tagName ||
+          tok.type == "string" && (tok.end != pos.ch || !/[\"\']/.test(tok.string.charAt(tok.string.length - 1)) || tok.string.length == 1) ||
+          tok.type == "tag" && state.type == "closeTag" ||
+          tok.string.indexOf("/") == (tok.string.length - 1) || // match something like <someTagName />
+          dontCloseTags && indexOf(dontCloseTags, lowerTagName) > -1 ||
+          closingTagExists(cm, tagName, pos, state, true))
+        return CodeMirror.Pass;
+
+      var indent = indentTags && indexOf(indentTags, lowerTagName) > -1;
+      replacements[i] = {indent: indent,
+                         text: ">" + (indent ? "\n\n" : "") + "</" + tagName + ">",
+                         newPos: indent ? CodeMirror.Pos(pos.line + 1, 0) : CodeMirror.Pos(pos.line, pos.ch + 1)};
+    }
+
+    for (var i = ranges.length - 1; i >= 0; i--) {
+      var info = replacements[i];
+      cm.replaceRange(info.text, ranges[i].head, ranges[i].anchor, "+insert");
+      var sel = cm.listSelections().slice(0);
+      sel[i] = {head: info.newPos, anchor: info.newPos};
+      cm.setSelections(sel);
+      if (info.indent) {
+        cm.indentLine(info.newPos.line, null, true);
+        cm.indentLine(info.newPos.line + 1, null, true);
+      }
+    }
+  }
+
+  function autoCloseCurrent(cm, typingSlash) {
+    var ranges = cm.listSelections(), replacements = [];
+    var head = typingSlash ? "/" : "</";
+    for (var i = 0; i < ranges.length; i++) {
+      if (!ranges[i].empty()) return CodeMirror.Pass;
+      var pos = ranges[i].head, tok = cm.getTokenAt(pos);
+      var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state;
+      if (typingSlash && (tok.type == "string" || tok.string.charAt(0) != "<" ||
+                          tok.start != pos.ch - 1))
+        return CodeMirror.Pass;
+      // Kludge to get around the fact that we are not in XML mode
+      // when completing in JS/CSS snippet in htmlmixed mode. Does not
+      // work for other XML embedded languages (there is no general
+      // way to go from a mixed mode to its current XML state).
+      if (inner.mode.name != "xml") {
+        if (cm.getMode().name == "htmlmixed" && inner.mode.name == "javascript")
+          replacements[i] = head + "script>";
+        else if (cm.getMode().name == "htmlmixed" && inner.mode.name == "css")
+          replacements[i] = head + "style>";
+        else
+          return CodeMirror.Pass;
+      } else {
+        if (!state.context || !state.context.tagName ||
+            closingTagExists(cm, state.context.tagName, pos, state))
+          return CodeMirror.Pass;
+        replacements[i] = head + state.context.tagName + ">";
+      }
+    }
+    cm.replaceSelections(replacements);
+    ranges = cm.listSelections();
+    for (var i = 0; i < ranges.length; i++)
+      if (i == ranges.length - 1 || ranges[i].head.line < ranges[i + 1].head.line)
+        cm.indentLine(ranges[i].head.line);
+  }
+
+  function autoCloseSlash(cm) {
+    if (cm.getOption("disableInput")) return CodeMirror.Pass;
+    return autoCloseCurrent(cm, true);
+  }
+
+  CodeMirror.commands.closeTag = function(cm) { return autoCloseCurrent(cm); };
+
+  function indexOf(collection, elt) {
+    if (collection.indexOf) return collection.indexOf(elt);
+    for (var i = 0, e = collection.length; i < e; ++i)
+      if (collection[i] == elt) return i;
+    return -1;
+  }
+
+  // If xml-fold is loaded, we use its functionality to try and verify
+  // whether a given tag is actually unclosed.
+  function closingTagExists(cm, tagName, pos, state, newTag) {
+    if (!CodeMirror.scanForClosingTag) return false;
+    var end = Math.min(cm.lastLine() + 1, pos.line + 500);
+    var nextClose = CodeMirror.scanForClosingTag(cm, pos, null, end);
+    if (!nextClose || nextClose.tag != tagName) return false;
+    var cx = state.context;
+    // If the immediate wrapping context contains onCx instances of
+    // the same tag, a closing tag only exists if there are at least
+    // that many closing tags of that type following.
+    for (var onCx = newTag ? 1 : 0; cx && cx.tagName == tagName; cx = cx.prev) ++onCx;
+    pos = nextClose.to;
+    for (var i = 1; i < onCx; i++) {
+      var next = CodeMirror.scanForClosingTag(cm, pos, null, end);
+      if (!next || next.tag != tagName) return false;
+      pos = next.to;
+    }
+    return true;
+  }
+});
diff --git a/src/main/resources/codemirror/addon/edit/continuelist.js b/src/main/resources/codemirror/addon/edit/continuelist.js
new file mode 100755
index 0000000..df5179f
--- /dev/null
+++ b/src/main/resources/codemirror/addon/edit/continuelist.js
@@ -0,0 +1,51 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var listRE = /^(\s*)(>[> ]*|[*+-]\s|(\d+)([.)]))(\s*)/,
+      emptyListRE = /^(\s*)(>[> ]*|[*+-]|(\d+)[.)])(\s*)$/,
+      unorderedListRE = /[*+-]\s/;
+
+  CodeMirror.commands.newlineAndIndentContinueMarkdownList = function(cm) {
+    if (cm.getOption("disableInput")) return CodeMirror.Pass;
+    var ranges = cm.listSelections(), replacements = [];
+    for (var i = 0; i < ranges.length; i++) {
+      var pos = ranges[i].head;
+      var eolState = cm.getStateAfter(pos.line);
+      var inList = eolState.list !== false;
+      var inQuote = eolState.quote !== 0;
+
+      var line = cm.getLine(pos.line), match = listRE.exec(line);
+      if (!ranges[i].empty() || (!inList && !inQuote) || !match) {
+        cm.execCommand("newlineAndIndent");
+        return;
+      }
+      if (emptyListRE.test(line)) {
+        cm.replaceRange("", {
+          line: pos.line, ch: 0
+        }, {
+          line: pos.line, ch: pos.ch + 1
+        });
+        replacements[i] = "\n";
+      } else {
+        var indent = match[1], after = match[5];
+        var bullet = unorderedListRE.test(match[2]) || match[2].indexOf(">") >= 0
+          ? match[2]
+          : (parseInt(match[3], 10) + 1) + match[4];
+
+        replacements[i] = "\n" + indent + bullet + after;
+      }
+    }
+
+    cm.replaceSelections(replacements);
+  };
+});
diff --git a/src/main/resources/codemirror/addon/edit/matchbrackets.js b/src/main/resources/codemirror/addon/edit/matchbrackets.js
new file mode 100755
index 0000000..70e1ae1
--- /dev/null
+++ b/src/main/resources/codemirror/addon/edit/matchbrackets.js
@@ -0,0 +1,120 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  var ie_lt8 = /MSIE \d/.test(navigator.userAgent) &&
+    (document.documentMode == null || document.documentMode < 8);
+
+  var Pos = CodeMirror.Pos;
+
+  var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
+
+  function findMatchingBracket(cm, where, strict, config) {
+    var line = cm.getLineHandle(where.line), pos = where.ch - 1;
+    var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
+    if (!match) return null;
+    var dir = match.charAt(1) == ">" ? 1 : -1;
+    if (strict && (dir > 0) != (pos == where.ch)) return null;
+    var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));
+
+    var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config);
+    if (found == null) return null;
+    return {from: Pos(where.line, pos), to: found && found.pos,
+            match: found && found.ch == match.charAt(0), forward: dir > 0};
+  }
+
+  // bracketRegex is used to specify which type of bracket to scan
+  // should be a regexp, e.g. /[[\]]/
+  //
+  // Note: If "where" is on an open bracket, then this bracket is ignored.
+  //
+  // Returns false when no bracket was found, null when it reached
+  // maxScanLines and gave up
+  function scanForBracket(cm, where, dir, style, config) {
+    var maxScanLen = (config && config.maxScanLineLength) || 10000;
+    var maxScanLines = (config && config.maxScanLines) || 1000;
+
+    var stack = [];
+    var re = config && config.bracketRegex ? config.bracketRegex : /[(){}[\]]/;
+    var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)
+                          : Math.max(cm.firstLine() - 1, where.line - maxScanLines);
+    for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {
+      var line = cm.getLine(lineNo);
+      if (!line) continue;
+      var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1;
+      if (line.length > maxScanLen) continue;
+      if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);
+      for (; pos != end; pos += dir) {
+        var ch = line.charAt(pos);
+        if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) {
+          var match = matching[ch];
+          if ((match.charAt(1) == ">") == (dir > 0)) stack.push(ch);
+          else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch};
+          else stack.pop();
+        }
+      }
+    }
+    return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null;
+  }
+
+  function matchBrackets(cm, autoclear, config) {
+    // Disable brace matching in long lines, since it'll cause hugely slow updates
+    var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;
+    var marks = [], ranges = cm.listSelections();
+    for (var i = 0; i < ranges.length; i++) {
+      var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, false, config);
+      if (match && cm.getLine(match.from.line).length <= maxHighlightLen) {
+        var style = match.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
+        marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style}));
+        if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen)
+          marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style}));
+      }
+    }
+
+    if (marks.length) {
+      // Kludge to work around the IE bug from issue #1193, where text
+      // input stops going to the textare whever this fires.
+      if (ie_lt8 && cm.state.focused) cm.focus();
+
+      var clear = function() {
+        cm.operation(function() {
+          for (var i = 0; i < marks.length; i++) marks[i].clear();
+        });
+      };
+      if (autoclear) setTimeout(clear, 800);
+      else return clear;
+    }
+  }
+
+  var currentlyHighlighted = null;
+  function doMatchBrackets(cm) {
+    cm.operation(function() {
+      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
+      currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets);
+    });
+  }
+
+  CodeMirror.defineOption("matchBrackets", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init)
+      cm.off("cursorActivity", doMatchBrackets);
+    if (val) {
+      cm.state.matchBrackets = typeof val == "object" ? val : {};
+      cm.on("cursorActivity", doMatchBrackets);
+    }
+  });
+
+  CodeMirror.defineExtension("matchBrackets", function() {matchBrackets(this, true);});
+  CodeMirror.defineExtension("findMatchingBracket", function(pos, strict, config){
+    return findMatchingBracket(this, pos, strict, config);
+  });
+  CodeMirror.defineExtension("scanForBracket", function(pos, dir, style, config){
+    return scanForBracket(this, pos, dir, style, config);
+  });
+});
diff --git a/src/main/resources/codemirror/addon/edit/matchtags.js b/src/main/resources/codemirror/addon/edit/matchtags.js
new file mode 100755
index 0000000..fb1911a
--- /dev/null
+++ b/src/main/resources/codemirror/addon/edit/matchtags.js
@@ -0,0 +1,66 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("../fold/xml-fold"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "../fold/xml-fold"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineOption("matchTags", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      cm.off("cursorActivity", doMatchTags);
+      cm.off("viewportChange", maybeUpdateMatch);
+      clear(cm);
+    }
+    if (val) {
+      cm.state.matchBothTags = typeof val == "object" && val.bothTags;
+      cm.on("cursorActivity", doMatchTags);
+      cm.on("viewportChange", maybeUpdateMatch);
+      doMatchTags(cm);
+    }
+  });
+
+  function clear(cm) {
+    if (cm.state.tagHit) cm.state.tagHit.clear();
+    if (cm.state.tagOther) cm.state.tagOther.clear();
+    cm.state.tagHit = cm.state.tagOther = null;
+  }
+
+  function doMatchTags(cm) {
+    cm.state.failedTagMatch = false;
+    cm.operation(function() {
+      clear(cm);
+      if (cm.somethingSelected()) return;
+      var cur = cm.getCursor(), range = cm.getViewport();
+      range.from = Math.min(range.from, cur.line); range.to = Math.max(cur.line + 1, range.to);
+      var match = CodeMirror.findMatchingTag(cm, cur, range);
+      if (!match) return;
+      if (cm.state.matchBothTags) {
+        var hit = match.at == "open" ? match.open : match.close;
+        if (hit) cm.state.tagHit = cm.markText(hit.from, hit.to, {className: "CodeMirror-matchingtag"});
+      }
+      var other = match.at == "close" ? match.open : match.close;
+      if (other)
+        cm.state.tagOther = cm.markText(other.from, other.to, {className: "CodeMirror-matchingtag"});
+      else
+        cm.state.failedTagMatch = true;
+    });
+  }
+
+  function maybeUpdateMatch(cm) {
+    if (cm.state.failedTagMatch) doMatchTags(cm);
+  }
+
+  CodeMirror.commands.toMatchingTag = function(cm) {
+    var found = CodeMirror.findMatchingTag(cm, cm.getCursor());
+    if (found) {
+      var other = found.at == "close" ? found.open : found.close;
+      if (other) cm.extendSelection(other.to, other.from);
+    }
+  };
+});
diff --git a/src/main/resources/codemirror/addon/edit/trailingspace.js b/src/main/resources/codemirror/addon/edit/trailingspace.js
new file mode 100755
index 0000000..fa7b56b
--- /dev/null
+++ b/src/main/resources/codemirror/addon/edit/trailingspace.js
@@ -0,0 +1,27 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  CodeMirror.defineOption("showTrailingSpace", false, function(cm, val, prev) {
+    if (prev == CodeMirror.Init) prev = false;
+    if (prev && !val)
+      cm.removeOverlay("trailingspace");
+    else if (!prev && val)
+      cm.addOverlay({
+        token: function(stream) {
+          for (var l = stream.string.length, i = l; i && /\s/.test(stream.string.charAt(i - 1)); --i) {}
+          if (i > stream.pos) { stream.pos = i; return null; }
+          stream.pos = l;
+          return "trailingspace";
+        },
+        name: "trailingspace"
+      });
+  });
+});
diff --git a/src/main/resources/codemirror/addon/fold/brace-fold.js b/src/main/resources/codemirror/addon/fold/brace-fold.js
new file mode 100755
index 0000000..1605f6c
--- /dev/null
+++ b/src/main/resources/codemirror/addon/fold/brace-fold.js
@@ -0,0 +1,105 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.registerHelper("fold", "brace", function(cm, start) {
+  var line = start.line, lineText = cm.getLine(line);
+  var startCh, tokenType;
+
+  function findOpening(openCh) {
+    for (var at = start.ch, pass = 0;;) {
+      var found = at <= 0 ? -1 : lineText.lastIndexOf(openCh, at - 1);
+      if (found == -1) {
+        if (pass == 1) break;
+        pass = 1;
+        at = lineText.length;
+        continue;
+      }
+      if (pass == 1 && found < start.ch) break;
+      tokenType = cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1));
+      if (!/^(comment|string)/.test(tokenType)) return found + 1;
+      at = found - 1;
+    }
+  }
+
+  var startToken = "{", endToken = "}", startCh = findOpening("{");
+  if (startCh == null) {
+    startToken = "[", endToken = "]";
+    startCh = findOpening("[");
+  }
+
+  if (startCh == null) return;
+  var count = 1, lastLine = cm.lastLine(), end, endCh;
+  outer: for (var i = line; i <= lastLine; ++i) {
+    var text = cm.getLine(i), pos = i == line ? startCh : 0;
+    for (;;) {
+      var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos);
+      if (nextOpen < 0) nextOpen = text.length;
+      if (nextClose < 0) nextClose = text.length;
+      pos = Math.min(nextOpen, nextClose);
+      if (pos == text.length) break;
+      if (cm.getTokenTypeAt(CodeMirror.Pos(i, pos + 1)) == tokenType) {
+        if (pos == nextOpen) ++count;
+        else if (!--count) { end = i; endCh = pos; break outer; }
+      }
+      ++pos;
+    }
+  }
+  if (end == null || line == end && endCh == startCh) return;
+  return {from: CodeMirror.Pos(line, startCh),
+          to: CodeMirror.Pos(end, endCh)};
+});
+
+CodeMirror.registerHelper("fold", "import", function(cm, start) {
+  function hasImport(line) {
+    if (line < cm.firstLine() || line > cm.lastLine()) return null;
+    var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
+    if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
+    if (start.type != "keyword" || start.string != "import") return null;
+    // Now find closing semicolon, return its position
+    for (var i = line, e = Math.min(cm.lastLine(), line + 10); i <= e; ++i) {
+      var text = cm.getLine(i), semi = text.indexOf(";");
+      if (semi != -1) return {startCh: start.end, end: CodeMirror.Pos(i, semi)};
+    }
+  }
+
+  var start = start.line, has = hasImport(start), prev;
+  if (!has || hasImport(start - 1) || ((prev = hasImport(start - 2)) && prev.end.line == start - 1))
+    return null;
+  for (var end = has.end;;) {
+    var next = hasImport(end.line + 1);
+    if (next == null) break;
+    end = next.end;
+  }
+  return {from: cm.clipPos(CodeMirror.Pos(start, has.startCh + 1)), to: end};
+});
+
+CodeMirror.registerHelper("fold", "include", function(cm, start) {
+  function hasInclude(line) {
+    if (line < cm.firstLine() || line > cm.lastLine()) return null;
+    var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
+    if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
+    if (start.type == "meta" && start.string.slice(0, 8) == "#include") return start.start + 8;
+  }
+
+  var start = start.line, has = hasInclude(start);
+  if (has == null || hasInclude(start - 1) != null) return null;
+  for (var end = start;;) {
+    var next = hasInclude(end + 1);
+    if (next == null) break;
+    ++end;
+  }
+  return {from: CodeMirror.Pos(start, has + 1),
+          to: cm.clipPos(CodeMirror.Pos(end))};
+});
+
+});
diff --git a/src/main/resources/codemirror/addon/fold/comment-fold.js b/src/main/resources/codemirror/addon/fold/comment-fold.js
new file mode 100755
index 0000000..b75db7e
--- /dev/null
+++ b/src/main/resources/codemirror/addon/fold/comment-fold.js
@@ -0,0 +1,57 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.registerGlobalHelper("fold", "comment", function(mode) {
+  return mode.blockCommentStart && mode.blockCommentEnd;
+}, function(cm, start) {
+  var mode = cm.getModeAt(start), startToken = mode.blockCommentStart, endToken = mode.blockCommentEnd;
+  if (!startToken || !endToken) return;
+  var line = start.line, lineText = cm.getLine(line);
+
+  var startCh;
+  for (var at = start.ch, pass = 0;;) {
+    var found = at <= 0 ? -1 : lineText.lastIndexOf(startToken, at - 1);
+    if (found == -1) {
+      if (pass == 1) return;
+      pass = 1;
+      at = lineText.length;
+      continue;
+    }
+    if (pass == 1 && found < start.ch) return;
+    if (/comment/.test(cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1)))) {
+      startCh = found + startToken.length;
+      break;
+    }
+    at = found - 1;
+  }
+
+  var depth = 1, lastLine = cm.lastLine(), end, endCh;
+  outer: for (var i = line; i <= lastLine; ++i) {
+    var text = cm.getLine(i), pos = i == line ? startCh : 0;
+    for (;;) {
+      var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos);
+      if (nextOpen < 0) nextOpen = text.length;
+      if (nextClose < 0) nextClose = text.length;
+      pos = Math.min(nextOpen, nextClose);
+      if (pos == text.length) break;
+      if (pos == nextOpen) ++depth;
+      else if (!--depth) { end = i; endCh = pos; break outer; }
+      ++pos;
+    }
+  }
+  if (end == null || line == end && endCh == startCh) return;
+  return {from: CodeMirror.Pos(line, startCh),
+          to: CodeMirror.Pos(end, endCh)};
+});
+
+});
diff --git a/src/main/resources/codemirror/addon/fold/foldcode.js b/src/main/resources/codemirror/addon/fold/foldcode.js
new file mode 100755
index 0000000..62911f9
--- /dev/null
+++ b/src/main/resources/codemirror/addon/fold/foldcode.js
@@ -0,0 +1,149 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  function doFold(cm, pos, options, force) {
+    if (options && options.call) {
+      var finder = options;
+      options = null;
+    } else {
+      var finder = getOption(cm, options, "rangeFinder");
+    }
+    if (typeof pos == "number") pos = CodeMirror.Pos(pos, 0);
+    var minSize = getOption(cm, options, "minFoldSize");
+
+    function getRange(allowFolded) {
+      var range = finder(cm, pos);
+      if (!range || range.to.line - range.from.line < minSize) return null;
+      var marks = cm.findMarksAt(range.from);
+      for (var i = 0; i < marks.length; ++i) {
+        if (marks[i].__isFold && force !== "fold") {
+          if (!allowFolded) return null;
+          range.cleared = true;
+          marks[i].clear();
+        }
+      }
+      return range;
+    }
+
+    var range = getRange(true);
+    if (getOption(cm, options, "scanUp")) while (!range && pos.line > cm.firstLine()) {
+      pos = CodeMirror.Pos(pos.line - 1, 0);
+      range = getRange(false);
+    }
+    if (!range || range.cleared || force === "unfold") return;
+
+    var myWidget = makeWidget(cm, options);
+    CodeMirror.on(myWidget, "mousedown", function(e) {
+      myRange.clear();
+      CodeMirror.e_preventDefault(e);
+    });
+    var myRange = cm.markText(range.from, range.to, {
+      replacedWith: myWidget,
+      clearOnEnter: true,
+      __isFold: true
+    });
+    myRange.on("clear", function(from, to) {
+      CodeMirror.signal(cm, "unfold", cm, from, to);
+    });
+    CodeMirror.signal(cm, "fold", cm, range.from, range.to);
+  }
+
+  function makeWidget(cm, options) {
+    var widget = getOption(cm, options, "widget");
+    if (typeof widget == "string") {
+      var text = document.createTextNode(widget);
+      widget = document.createElement("span");
+      widget.appendChild(text);
+      widget.className = "CodeMirror-foldmarker";
+    }
+    return widget;
+  }
+
+  // Clumsy backwards-compatible interface
+  CodeMirror.newFoldFunction = function(rangeFinder, widget) {
+    return function(cm, pos) { doFold(cm, pos, {rangeFinder: rangeFinder, widget: widget}); };
+  };
+
+  // New-style interface
+  CodeMirror.defineExtension("foldCode", function(pos, options, force) {
+    doFold(this, pos, options, force);
+  });
+
+  CodeMirror.defineExtension("isFolded", function(pos) {
+    var marks = this.findMarksAt(pos);
+    for (var i = 0; i < marks.length; ++i)
+      if (marks[i].__isFold) return true;
+  });
+
+  CodeMirror.commands.toggleFold = function(cm) {
+    cm.foldCode(cm.getCursor());
+  };
+  CodeMirror.commands.fold = function(cm) {
+    cm.foldCode(cm.getCursor(), null, "fold");
+  };
+  CodeMirror.commands.unfold = function(cm) {
+    cm.foldCode(cm.getCursor(), null, "unfold");
+  };
+  CodeMirror.commands.foldAll = function(cm) {
+    cm.operation(function() {
+      for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++)
+        cm.foldCode(CodeMirror.Pos(i, 0), null, "fold");
+    });
+  };
+  CodeMirror.commands.unfoldAll = function(cm) {
+    cm.operation(function() {
+      for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++)
+        cm.foldCode(CodeMirror.Pos(i, 0), null, "unfold");
+    });
+  };
+
+  CodeMirror.registerHelper("fold", "combine", function() {
+    var funcs = Array.prototype.slice.call(arguments, 0);
+    return function(cm, start) {
+      for (var i = 0; i < funcs.length; ++i) {
+        var found = funcs[i](cm, start);
+        if (found) return found;
+      }
+    };
+  });
+
+  CodeMirror.registerHelper("fold", "auto", function(cm, start) {
+    var helpers = cm.getHelpers(start, "fold");
+    for (var i = 0; i < helpers.length; i++) {
+      var cur = helpers[i](cm, start);
+      if (cur) return cur;
+    }
+  });
+
+  var defaultOptions = {
+    rangeFinder: CodeMirror.fold.auto,
+    widget: "\u2194",
+    minFoldSize: 0,
+    scanUp: false
+  };
+
+  CodeMirror.defineOption("foldOptions", null);
+
+  function getOption(cm, options, name) {
+    if (options && options[name] !== undefined)
+      return options[name];
+    var editorOptions = cm.options.foldOptions;
+    if (editorOptions && editorOptions[name] !== undefined)
+      return editorOptions[name];
+    return defaultOptions[name];
+  }
+
+  CodeMirror.defineExtension("foldOption", function(options, name) {
+    return getOption(this, options, name);
+  });
+});
diff --git a/src/main/resources/codemirror/addon/fold/foldgutter.css b/src/main/resources/codemirror/addon/fold/foldgutter.css
new file mode 100755
index 0000000..ad19ae2
--- /dev/null
+++ b/src/main/resources/codemirror/addon/fold/foldgutter.css
@@ -0,0 +1,20 @@
+.CodeMirror-foldmarker {
+  color: blue;
+  text-shadow: #b9f 1px 1px 2px, #b9f -1px -1px 2px, #b9f 1px -1px 2px, #b9f -1px 1px 2px;
+  font-family: arial;
+  line-height: .3;
+  cursor: pointer;
+}
+.CodeMirror-foldgutter {
+  width: .7em;
+}
+.CodeMirror-foldgutter-open,
+.CodeMirror-foldgutter-folded {
+  cursor: pointer;
+}
+.CodeMirror-foldgutter-open:after {
+  content: "\25BE";
+}
+.CodeMirror-foldgutter-folded:after {
+  content: "\25B8";
+}
diff --git a/src/main/resources/codemirror/addon/fold/foldgutter.js b/src/main/resources/codemirror/addon/fold/foldgutter.js
new file mode 100755
index 0000000..ed7bd87
--- /dev/null
+++ b/src/main/resources/codemirror/addon/fold/foldgutter.js
@@ -0,0 +1,146 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("./foldcode"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "./foldcode"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineOption("foldGutter", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      cm.clearGutter(cm.state.foldGutter.options.gutter);
+      cm.state.foldGutter = null;
+      cm.off("gutterClick", onGutterClick);
+      cm.off("change", onChange);
+      cm.off("viewportChange", onViewportChange);
+      cm.off("fold", onFold);
+      cm.off("unfold", onFold);
+      cm.off("swapDoc", updateInViewport);
+    }
+    if (val) {
+      cm.state.foldGutter = new State(parseOptions(val));
+      updateInViewport(cm);
+      cm.on("gutterClick", onGutterClick);
+      cm.on("change", onChange);
+      cm.on("viewportChange", onViewportChange);
+      cm.on("fold", onFold);
+      cm.on("unfold", onFold);
+      cm.on("swapDoc", updateInViewport);
+    }
+  });
+
+  var Pos = CodeMirror.Pos;
+
+  function State(options) {
+    this.options = options;
+    this.from = this.to = 0;
+  }
+
+  function parseOptions(opts) {
+    if (opts === true) opts = {};
+    if (opts.gutter == null) opts.gutter = "CodeMirror-foldgutter";
+    if (opts.indicatorOpen == null) opts.indicatorOpen = "CodeMirror-foldgutter-open";
+    if (opts.indicatorFolded == null) opts.indicatorFolded = "CodeMirror-foldgutter-folded";
+    return opts;
+  }
+
+  function isFolded(cm, line) {
+    var marks = cm.findMarksAt(Pos(line));
+    for (var i = 0; i < marks.length; ++i)
+      if (marks[i].__isFold && marks[i].find().from.line == line) return marks[i];
+  }
+
+  function marker(spec) {
+    if (typeof spec == "string") {
+      var elt = document.createElement("div");
+      elt.className = spec + " CodeMirror-guttermarker-subtle";
+      return elt;
+    } else {
+      return spec.cloneNode(true);
+    }
+  }
+
+  function updateFoldInfo(cm, from, to) {
+    var opts = cm.state.foldGutter.options, cur = from;
+    var minSize = cm.foldOption(opts, "minFoldSize");
+    var func = cm.foldOption(opts, "rangeFinder");
+    cm.eachLine(from, to, function(line) {
+      var mark = null;
+      if (isFolded(cm, cur)) {
+        mark = marker(opts.indicatorFolded);
+      } else {
+        var pos = Pos(cur, 0);
+        var range = func && func(cm, pos);
+        if (range && range.to.line - range.from.line >= minSize)
+          mark = marker(opts.indicatorOpen);
+      }
+      cm.setGutterMarker(line, opts.gutter, mark);
+      ++cur;
+    });
+  }
+
+  function updateInViewport(cm) {
+    var vp = cm.getViewport(), state = cm.state.foldGutter;
+    if (!state) return;
+    cm.operation(function() {
+      updateFoldInfo(cm, vp.from, vp.to);
+    });
+    state.from = vp.from; state.to = vp.to;
+  }
+
+  function onGutterClick(cm, line, gutter) {
+    var state = cm.state.foldGutter;
+    if (!state) return;
+    var opts = state.options;
+    if (gutter != opts.gutter) return;
+    var folded = isFolded(cm, line);
+    if (folded) folded.clear();
+    else cm.foldCode(Pos(line, 0), opts.rangeFinder);
+  }
+
+  function onChange(cm) {
+    var state = cm.state.foldGutter;
+    if (!state) return;
+    var opts = state.options;
+    state.from = state.to = 0;
+    clearTimeout(state.changeUpdate);
+    state.changeUpdate = setTimeout(function() { updateInViewport(cm); }, opts.foldOnChangeTimeSpan || 600);
+  }
+
+  function onViewportChange(cm) {
+    var state = cm.state.foldGutter;
+    if (!state) return;
+    var opts = state.options;
+    clearTimeout(state.changeUpdate);
+    state.changeUpdate = setTimeout(function() {
+      var vp = cm.getViewport();
+      if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) {
+        updateInViewport(cm);
+      } else {
+        cm.operation(function() {
+          if (vp.from < state.from) {
+            updateFoldInfo(cm, vp.from, state.from);
+            state.from = vp.from;
+          }
+          if (vp.to > state.to) {
+            updateFoldInfo(cm, state.to, vp.to);
+            state.to = vp.to;
+          }
+        });
+      }
+    }, opts.updateViewportTimeSpan || 400);
+  }
+
+  function onFold(cm, from) {
+    var state = cm.state.foldGutter;
+    if (!state) return;
+    var line = from.line;
+    if (line >= state.from && line < state.to)
+      updateFoldInfo(cm, line, line + 1);
+  }
+});
diff --git a/src/main/resources/codemirror/addon/fold/indent-fold.js b/src/main/resources/codemirror/addon/fold/indent-fold.js
new file mode 100755
index 0000000..e29f15e
--- /dev/null
+++ b/src/main/resources/codemirror/addon/fold/indent-fold.js
@@ -0,0 +1,44 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.registerHelper("fold", "indent", function(cm, start) {
+  var tabSize = cm.getOption("tabSize"), firstLine = cm.getLine(start.line);
+  if (!/\S/.test(firstLine)) return;
+  var getIndent = function(line) {
+    return CodeMirror.countColumn(line, null, tabSize);
+  };
+  var myIndent = getIndent(firstLine);
+  var lastLineInFold = null;
+  // Go through lines until we find a line that definitely doesn't belong in
+  // the block we're folding, or to the end.
+  for (var i = start.line + 1, end = cm.lastLine(); i <= end; ++i) {
+    var curLine = cm.getLine(i);
+    var curIndent = getIndent(curLine);
+    if (curIndent > myIndent) {
+      // Lines with a greater indent are considered part of the block.
+      lastLineInFold = i;
+    } else if (!/\S/.test(curLine)) {
+      // Empty lines might be breaks within the block we're trying to fold.
+    } else {
+      // A non-empty line at an indent equal to or less than ours marks the
+      // start of another block.
+      break;
+    }
+  }
+  if (lastLineInFold) return {
+    from: CodeMirror.Pos(start.line, firstLine.length),
+    to: CodeMirror.Pos(lastLineInFold, cm.getLine(lastLineInFold).length)
+  };
+});
+
+});
diff --git a/src/main/resources/codemirror/addon/fold/markdown-fold.js b/src/main/resources/codemirror/addon/fold/markdown-fold.js
new file mode 100755
index 0000000..ce84c94
--- /dev/null
+++ b/src/main/resources/codemirror/addon/fold/markdown-fold.js
@@ -0,0 +1,49 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.registerHelper("fold", "markdown", function(cm, start) {
+  var maxDepth = 100;
+
+  function isHeader(lineNo) {
+    var tokentype = cm.getTokenTypeAt(CodeMirror.Pos(lineNo, 0));
+    return tokentype && /\bheader\b/.test(tokentype);
+  }
+
+  function headerLevel(lineNo, line, nextLine) {
+    var match = line && line.match(/^#+/);
+    if (match && isHeader(lineNo)) return match[0].length;
+    match = nextLine && nextLine.match(/^[=\-]+\s*$/);
+    if (match && isHeader(lineNo + 1)) return nextLine[0] == "=" ? 1 : 2;
+    return maxDepth;
+  }
+
+  var firstLine = cm.getLine(start.line), nextLine = cm.getLine(start.line + 1);
+  var level = headerLevel(start.line, firstLine, nextLine);
+  if (level === maxDepth) return undefined;
+
+  var lastLineNo = cm.lastLine();
+  var end = start.line, nextNextLine = cm.getLine(end + 2);
+  while (end < lastLineNo) {
+    if (headerLevel(end + 1, nextLine, nextNextLine) <= level) break;
+    ++end;
+    nextLine = nextNextLine;
+    nextNextLine = cm.getLine(end + 2);
+  }
+
+  return {
+    from: CodeMirror.Pos(start.line, firstLine.length),
+    to: CodeMirror.Pos(end, cm.getLine(end).length)
+  };
+});
+
+});
diff --git a/src/main/resources/codemirror/addon/fold/xml-fold.js b/src/main/resources/codemirror/addon/fold/xml-fold.js
new file mode 100755
index 0000000..504727f
--- /dev/null
+++ b/src/main/resources/codemirror/addon/fold/xml-fold.js
@@ -0,0 +1,182 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var Pos = CodeMirror.Pos;
+  function cmp(a, b) { return a.line - b.line || a.ch - b.ch; }
+
+  var nameStartChar = "A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
+  var nameChar = nameStartChar + "\-\:\.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+  var xmlTagStart = new RegExp("<(/?)([" + nameStartChar + "][" + nameChar + "]*)", "g");
+
+  function Iter(cm, line, ch, range) {
+    this.line = line; this.ch = ch;
+    this.cm = cm; this.text = cm.getLine(line);
+    this.min = range ? range.from : cm.firstLine();
+    this.max = range ? range.to - 1 : cm.lastLine();
+  }
+
+  function tagAt(iter, ch) {
+    var type = iter.cm.getTokenTypeAt(Pos(iter.line, ch));
+    return type && /\btag\b/.test(type);
+  }
+
+  function nextLine(iter) {
+    if (iter.line >= iter.max) return;
+    iter.ch = 0;
+    iter.text = iter.cm.getLine(++iter.line);
+    return true;
+  }
+  function prevLine(iter) {
+    if (iter.line <= iter.min) return;
+    iter.text = iter.cm.getLine(--iter.line);
+    iter.ch = iter.text.length;
+    return true;
+  }
+
+  function toTagEnd(iter) {
+    for (;;) {
+      var gt = iter.text.indexOf(">", iter.ch);
+      if (gt == -1) { if (nextLine(iter)) continue; else return; }
+      if (!tagAt(iter, gt + 1)) { iter.ch = gt + 1; continue; }
+      var lastSlash = iter.text.lastIndexOf("/", gt);
+      var selfClose = lastSlash > -1 && !/\S/.test(iter.text.slice(lastSlash + 1, gt));
+      iter.ch = gt + 1;
+      return selfClose ? "selfClose" : "regular";
+    }
+  }
+  function toTagStart(iter) {
+    for (;;) {
+      var lt = iter.ch ? iter.text.lastIndexOf("<", iter.ch - 1) : -1;
+      if (lt == -1) { if (prevLine(iter)) continue; else return; }
+      if (!tagAt(iter, lt + 1)) { iter.ch = lt; continue; }
+      xmlTagStart.lastIndex = lt;
+      iter.ch = lt;
+      var match = xmlTagStart.exec(iter.text);
+      if (match && match.index == lt) return match;
+    }
+  }
+
+  function toNextTag(iter) {
+    for (;;) {
+      xmlTagStart.lastIndex = iter.ch;
+      var found = xmlTagStart.exec(iter.text);
+      if (!found) { if (nextLine(iter)) continue; else return; }
+      if (!tagAt(iter, found.index + 1)) { iter.ch = found.index + 1; continue; }
+      iter.ch = found.index + found[0].length;
+      return found;
+    }
+  }
+  function toPrevTag(iter) {
+    for (;;) {
+      var gt = iter.ch ? iter.text.lastIndexOf(">", iter.ch - 1) : -1;
+      if (gt == -1) { if (prevLine(iter)) continue; else return; }
+      if (!tagAt(iter, gt + 1)) { iter.ch = gt; continue; }
+      var lastSlash = iter.text.lastIndexOf("/", gt);
+      var selfClose = lastSlash > -1 && !/\S/.test(iter.text.slice(lastSlash + 1, gt));
+      iter.ch = gt + 1;
+      return selfClose ? "selfClose" : "regular";
+    }
+  }
+
+  function findMatchingClose(iter, tag) {
+    var stack = [];
+    for (;;) {
+      var next = toNextTag(iter), end, startLine = iter.line, startCh = iter.ch - (next ? next[0].length : 0);
+      if (!next || !(end = toTagEnd(iter))) return;
+      if (end == "selfClose") continue;
+      if (next[1]) { // closing tag
+        for (var i = stack.length - 1; i >= 0; --i) if (stack[i] == next[2]) {
+          stack.length = i;
+          break;
+        }
+        if (i < 0 && (!tag || tag == next[2])) return {
+          tag: next[2],
+          from: Pos(startLine, startCh),
+          to: Pos(iter.line, iter.ch)
+        };
+      } else { // opening tag
+        stack.push(next[2]);
+      }
+    }
+  }
+  function findMatchingOpen(iter, tag) {
+    var stack = [];
+    for (;;) {
+      var prev = toPrevTag(iter);
+      if (!prev) return;
+      if (prev == "selfClose") { toTagStart(iter); continue; }
+      var endLine = iter.line, endCh = iter.ch;
+      var start = toTagStart(iter);
+      if (!start) return;
+      if (start[1]) { // closing tag
+        stack.push(start[2]);
+      } else { // opening tag
+        for (var i = stack.length - 1; i >= 0; --i) if (stack[i] == start[2]) {
+          stack.length = i;
+          break;
+        }
+        if (i < 0 && (!tag || tag == start[2])) return {
+          tag: start[2],
+          from: Pos(iter.line, iter.ch),
+          to: Pos(endLine, endCh)
+        };
+      }
+    }
+  }
+
+  CodeMirror.registerHelper("fold", "xml", function(cm, start) {
+    var iter = new Iter(cm, start.line, 0);
+    for (;;) {
+      var openTag = toNextTag(iter), end;
+      if (!openTag || iter.line != start.line || !(end = toTagEnd(iter))) return;
+      if (!openTag[1] && end != "selfClose") {
+        var start = Pos(iter.line, iter.ch);
+        var close = findMatchingClose(iter, openTag[2]);
+        return close && {from: start, to: close.from};
+      }
+    }
+  });
+  CodeMirror.findMatchingTag = function(cm, pos, range) {
+    var iter = new Iter(cm, pos.line, pos.ch, range);
+    if (iter.text.indexOf(">") == -1 && iter.text.indexOf("<") == -1) return;
+    var end = toTagEnd(iter), to = end && Pos(iter.line, iter.ch);
+    var start = end && toTagStart(iter);
+    if (!end || !start || cmp(iter, pos) > 0) return;
+    var here = {from: Pos(iter.line, iter.ch), to: to, tag: start[2]};
+    if (end == "selfClose") return {open: here, close: null, at: "open"};
+
+    if (start[1]) { // closing tag
+      return {open: findMatchingOpen(iter, start[2]), close: here, at: "close"};
+    } else { // opening tag
+      iter = new Iter(cm, to.line, to.ch, range);
+      return {open: here, close: findMatchingClose(iter, start[2]), at: "open"};
+    }
+  };
+
+  CodeMirror.findEnclosingTag = function(cm, pos, range) {
+    var iter = new Iter(cm, pos.line, pos.ch, range);
+    for (;;) {
+      var open = findMatchingOpen(iter);
+      if (!open) break;
+      var forward = new Iter(cm, pos.line, pos.ch, range);
+      var close = findMatchingClose(forward, open.tag);
+      if (close) return {open: open, close: close};
+    }
+  };
+
+  // Used by addon/edit/closetag.js
+  CodeMirror.scanForClosingTag = function(cm, pos, name, end) {
+    var iter = new Iter(cm, pos.line, pos.ch, end ? {from: 0, to: end} : null);
+    return findMatchingClose(iter, name);
+  };
+});
diff --git a/src/main/resources/codemirror/addon/hint/anyword-hint.js b/src/main/resources/codemirror/addon/hint/anyword-hint.js
new file mode 100755
index 0000000..8e74a92
--- /dev/null
+++ b/src/main/resources/codemirror/addon/hint/anyword-hint.js
@@ -0,0 +1,41 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var WORD = /[\w$]+/, RANGE = 500;
+
+  CodeMirror.registerHelper("hint", "anyword", function(editor, options) {
+    var word = options && options.word || WORD;
+    var range = options && options.range || RANGE;
+    var cur = editor.getCursor(), curLine = editor.getLine(cur.line);
+    var end = cur.ch, start = end;
+    while (start && word.test(curLine.charAt(start - 1))) --start;
+    var curWord = start != end && curLine.slice(start, end);
+
+    var list = [], seen = {};
+    var re = new RegExp(word.source, "g");
+    for (var dir = -1; dir <= 1; dir += 2) {
+      var line = cur.line, endLine = Math.min(Math.max(line + dir * range, editor.firstLine()), editor.lastLine()) + dir;
+      for (; line != endLine; line += dir) {
+        var text = editor.getLine(line), m;
+        while (m = re.exec(text)) {
+          if (line == cur.line && m[0] === curWord) continue;
+          if ((!curWord || m[0].lastIndexOf(curWord, 0) == 0) && !Object.prototype.hasOwnProperty.call(seen, m[0])) {
+            seen[m[0]] = true;
+            list.push(m[0]);
+          }
+        }
+      }
+    }
+    return {list: list, from: CodeMirror.Pos(cur.line, start), to: CodeMirror.Pos(cur.line, end)};
+  });
+});
diff --git a/src/main/resources/codemirror/addon/hint/css-hint.js b/src/main/resources/codemirror/addon/hint/css-hint.js
new file mode 100755
index 0000000..2264272
--- /dev/null
+++ b/src/main/resources/codemirror/addon/hint/css-hint.js
@@ -0,0 +1,60 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("../../mode/css/css"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "../../mode/css/css"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var pseudoClasses = {link: 1, visited: 1, active: 1, hover: 1, focus: 1,
+                       "first-letter": 1, "first-line": 1, "first-child": 1,
+                       before: 1, after: 1, lang: 1};
+
+  CodeMirror.registerHelper("hint", "css", function(cm) {
+    var cur = cm.getCursor(), token = cm.getTokenAt(cur);
+    var inner = CodeMirror.innerMode(cm.getMode(), token.state);
+    if (inner.mode.name != "css") return;
+
+    if (token.type == "keyword" && "!important".indexOf(token.string) == 0)
+      return {list: ["!important"], from: CodeMirror.Pos(cur.line, token.start),
+              to: CodeMirror.Pos(cur.line, token.end)};
+
+    var start = token.start, end = cur.ch, word = token.string.slice(0, end - start);
+    if (/[^\w$_-]/.test(word)) {
+      word = ""; start = end = cur.ch;
+    }
+
+    var spec = CodeMirror.resolveMode("text/css");
+
+    var result = [];
+    function add(keywords) {
+      for (var name in keywords)
+        if (!word || name.lastIndexOf(word, 0) == 0)
+          result.push(name);
+    }
+
+    var st = inner.state.state;
+    if (st == "pseudo" || token.type == "variable-3") {
+      add(pseudoClasses);
+    } else if (st == "block" || st == "maybeprop") {
+      add(spec.propertyKeywords);
+    } else if (st == "prop" || st == "parens" || st == "at" || st == "params") {
+      add(spec.valueKeywords);
+      add(spec.colorKeywords);
+    } else if (st == "media" || st == "media_parens") {
+      add(spec.mediaTypes);
+      add(spec.mediaFeatures);
+    }
+
+    if (result.length) return {
+      list: result,
+      from: CodeMirror.Pos(cur.line, start),
+      to: CodeMirror.Pos(cur.line, end)
+    };
+  });
+});
diff --git a/src/main/resources/codemirror/addon/hint/html-hint.js b/src/main/resources/codemirror/addon/hint/html-hint.js
new file mode 100755
index 0000000..c6769bc
--- /dev/null
+++ b/src/main/resources/codemirror/addon/hint/html-hint.js
@@ -0,0 +1,348 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("./xml-hint"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "./xml-hint"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var langs = "ab aa af ak sq am ar an hy as av ae ay az bm ba eu be bn bh bi bs br bg my ca ch ce ny zh cv kw co cr hr cs da dv nl dz en eo et ee fo fj fi fr ff gl ka de el gn gu ht ha he hz hi ho hu ia id ie ga ig ik io is it iu ja jv kl kn kr ks kk km ki rw ky kv kg ko ku kj la lb lg li ln lo lt lu lv gv mk mg ms ml mt mi mr mh mn na nv nb nd ne ng nn no ii nr oc oj cu om or os pa pi fa pl ps pt qu rm rn ro ru sa sc sd se sm sg sr gd sn si sk sl so st es su sw ss sv ta te tg th ti bo tk tl tn to tr ts tt tw ty ug uk ur uz ve vi vo wa cy wo fy xh yi yo za zu".split(" ");
+  var targets = ["_blank", "_self", "_top", "_parent"];
+  var charsets = ["ascii", "utf-8", "utf-16", "latin1", "latin1"];
+  var methods = ["get", "post", "put", "delete"];
+  var encs = ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"];
+  var media = ["all", "screen", "print", "embossed", "braille", "handheld", "print", "projection", "screen", "tty", "tv", "speech",
+               "3d-glasses", "resolution [>][<][=] [X]", "device-aspect-ratio: X/Y", "orientation:portrait",
+               "orientation:landscape", "device-height: [X]", "device-width: [X]"];
+  var s = { attrs: {} }; // Simple tag, reused for a whole lot of tags
+
+  var data = {
+    a: {
+      attrs: {
+        href: null, ping: null, type: null,
+        media: media,
+        target: targets,
+        hreflang: langs
+      }
+    },
+    abbr: s,
+    acronym: s,
+    address: s,
+    applet: s,
+    area: {
+      attrs: {
+        alt: null, coords: null, href: null, target: null, ping: null,
+        media: media, hreflang: langs, type: null,
+        shape: ["default", "rect", "circle", "poly"]
+      }
+    },
+    article: s,
+    aside: s,
+    audio: {
+      attrs: {
+        src: null, mediagroup: null,
+        crossorigin: ["anonymous", "use-credentials"],
+        preload: ["none", "metadata", "auto"],
+        autoplay: ["", "autoplay"],
+        loop: ["", "loop"],
+        controls: ["", "controls"]
+      }
+    },
+    b: s,
+    base: { attrs: { href: null, target: targets } },
+    basefont: s,
+    bdi: s,
+    bdo: s,
+    big: s,
+    blockquote: { attrs: { cite: null } },
+    body: s,
+    br: s,
+    button: {
+      attrs: {
+        form: null, formaction: null, name: null, value: null,
+        autofocus: ["", "autofocus"],
+        disabled: ["", "autofocus"],
+        formenctype: encs,
+        formmethod: methods,
+        formnovalidate: ["", "novalidate"],
+        formtarget: targets,
+        type: ["submit", "reset", "button"]
+      }
+    },
+    canvas: { attrs: { width: null, height: null } },
+    caption: s,
+    center: s,
+    cite: s,
+    code: s,
+    col: { attrs: { span: null } },
+    colgroup: { attrs: { span: null } },
+    command: {
+      attrs: {
+        type: ["command", "checkbox", "radio"],
+        label: null, icon: null, radiogroup: null, command: null, title: null,
+        disabled: ["", "disabled"],
+        checked: ["", "checked"]
+      }
+    },
+    data: { attrs: { value: null } },
+    datagrid: { attrs: { disabled: ["", "disabled"], multiple: ["", "multiple"] } },
+    datalist: { attrs: { data: null } },
+    dd: s,
+    del: { attrs: { cite: null, datetime: null } },
+    details: { attrs: { open: ["", "open"] } },
+    dfn: s,
+    dir: s,
+    div: s,
+    dl: s,
+    dt: s,
+    em: s,
+    embed: { attrs: { src: null, type: null, width: null, height: null } },
+    eventsource: { attrs: { src: null } },
+    fieldset: { attrs: { disabled: ["", "disabled"], form: null, name: null } },
+    figcaption: s,
+    figure: s,
+    font: s,
+    footer: s,
+    form: {
+      attrs: {
+        action: null, name: null,
+        "accept-charset": charsets,
+        autocomplete: ["on", "off"],
+        enctype: encs,
+        method: methods,
+        novalidate: ["", "novalidate"],
+        target: targets
+      }
+    },
+    frame: s,
+    frameset: s,
+    h1: s, h2: s, h3: s, h4: s, h5: s, h6: s,
+    head: {
+      attrs: {},
+      children: ["title", "base", "link", "style", "meta", "script", "noscript", "command"]
+    },
+    header: s,
+    hgroup: s,
+    hr: s,
+    html: {
+      attrs: { manifest: null },
+      children: ["head", "body"]
+    },
+    i: s,
+    iframe: {
+      attrs: {
+        src: null, srcdoc: null, name: null, width: null, height: null,
+        sandbox: ["allow-top-navigation", "allow-same-origin", "allow-forms", "allow-scripts"],
+        seamless: ["", "seamless"]
+      }
+    },
+    img: {
+      attrs: {
+        alt: null, src: null, ismap: null, usemap: null, width: null, height: null,
+        crossorigin: ["anonymous", "use-credentials"]
+      }
+    },
+    input: {
+      attrs: {
+        alt: null, dirname: null, form: null, formaction: null,
+        height: null, list: null, max: null, maxlength: null, min: null,
+        name: null, pattern: null, placeholder: null, size: null, src: null,
+        step: null, value: null, width: null,
+        accept: ["audio/*", "video/*", "image/*"],
+        autocomplete: ["on", "off"],
+        autofocus: ["", "autofocus"],
+        checked: ["", "checked"],
+        disabled: ["", "disabled"],
+        formenctype: encs,
+        formmethod: methods,
+        formnovalidate: ["", "novalidate"],
+        formtarget: targets,
+        multiple: ["", "multiple"],
+        readonly: ["", "readonly"],
+        required: ["", "required"],
+        type: ["hidden", "text", "search", "tel", "url", "email", "password", "datetime", "date", "month",
+               "week", "time", "datetime-local", "number", "range", "color", "checkbox", "radio",
+               "file", "submit", "image", "reset", "button"]
+      }
+    },
+    ins: { attrs: { cite: null, datetime: null } },
+    kbd: s,
+    keygen: {
+      attrs: {
+        challenge: null, form: null, name: null,
+        autofocus: ["", "autofocus"],
+        disabled: ["", "disabled"],
+        keytype: ["RSA"]
+      }
+    },
+    label: { attrs: { "for": null, form: null } },
+    legend: s,
+    li: { attrs: { value: null } },
+    link: {
+      attrs: {
+        href: null, type: null,
+        hreflang: langs,
+        media: media,
+        sizes: ["all", "16x16", "16x16 32x32", "16x16 32x32 64x64"]
+      }
+    },
+    map: { attrs: { name: null } },
+    mark: s,
+    menu: { attrs: { label: null, type: ["list", "context", "toolbar"] } },
+    meta: {
+      attrs: {
+        content: null,
+        charset: charsets,
+        name: ["viewport", "application-name", "author", "description", "generator", "keywords"],
+        "http-equiv": ["content-language", "content-type", "default-style", "refresh"]
+      }
+    },
+    meter: { attrs: { value: null, min: null, low: null, high: null, max: null, optimum: null } },
+    nav: s,
+    noframes: s,
+    noscript: s,
+    object: {
+      attrs: {
+        data: null, type: null, name: null, usemap: null, form: null, width: null, height: null,
+        typemustmatch: ["", "typemustmatch"]
+      }
+    },
+    ol: { attrs: { reversed: ["", "reversed"], start: null, type: ["1", "a", "A", "i", "I"] } },
+    optgroup: { attrs: { disabled: ["", "disabled"], label: null } },
+    option: { attrs: { disabled: ["", "disabled"], label: null, selected: ["", "selected"], value: null } },
+    output: { attrs: { "for": null, form: null, name: null } },
+    p: s,
+    param: { attrs: { name: null, value: null } },
+    pre: s,
+    progress: { attrs: { value: null, max: null } },
+    q: { attrs: { cite: null } },
+    rp: s,
+    rt: s,
+    ruby: s,
+    s: s,
+    samp: s,
+    script: {
+      attrs: {
+        type: ["text/javascript"],
+        src: null,
+        async: ["", "async"],
+        defer: ["", "defer"],
+        charset: charsets
+      }
+    },
+    section: s,
+    select: {
+      attrs: {
+        form: null, name: null, size: null,
+        autofocus: ["", "autofocus"],
+        disabled: ["", "disabled"],
+        multiple: ["", "multiple"]
+      }
+    },
+    small: s,
+    source: { attrs: { src: null, type: null, media: null } },
+    span: s,
+    strike: s,
+    strong: s,
+    style: {
+      attrs: {
+        type: ["text/css"],
+        media: media,
+        scoped: null
+      }
+    },
+    sub: s,
+    summary: s,
+    sup: s,
+    table: s,
+    tbody: s,
+    td: { attrs: { colspan: null, rowspan: null, headers: null } },
+    textarea: {
+      attrs: {
+        dirname: null, form: null, maxlength: null, name: null, placeholder: null,
+        rows: null, cols: null,
+        autofocus: ["", "autofocus"],
+        disabled: ["", "disabled"],
+        readonly: ["", "readonly"],
+        required: ["", "required"],
+        wrap: ["soft", "hard"]
+      }
+    },
+    tfoot: s,
+    th: { attrs: { colspan: null, rowspan: null, headers: null, scope: ["row", "col", "rowgroup", "colgroup"] } },
+    thead: s,
+    time: { attrs: { datetime: null } },
+    title: s,
+    tr: s,
+    track: {
+      attrs: {
+        src: null, label: null, "default": null,
+        kind: ["subtitles", "captions", "descriptions", "chapters", "metadata"],
+        srclang: langs
+      }
+    },
+    tt: s,
+    u: s,
+    ul: s,
+    "var": s,
+    video: {
+      attrs: {
+        src: null, poster: null, width: null, height: null,
+        crossorigin: ["anonymous", "use-credentials"],
+        preload: ["auto", "metadata", "none"],
+        autoplay: ["", "autoplay"],
+        mediagroup: ["movie"],
+        muted: ["", "muted"],
+        controls: ["", "controls"]
+      }
+    },
+    wbr: s
+  };
+
+  var globalAttrs = {
+    accesskey: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
+    "class": null,
+    contenteditable: ["true", "false"],
+    contextmenu: null,
+    dir: ["ltr", "rtl", "auto"],
+    draggable: ["true", "false", "auto"],
+    dropzone: ["copy", "move", "link", "string:", "file:"],
+    hidden: ["hidden"],
+    id: null,
+    inert: ["inert"],
+    itemid: null,
+    itemprop: null,
+    itemref: null,
+    itemscope: ["itemscope"],
+    itemtype: null,
+    lang: ["en", "es"],
+    spellcheck: ["true", "false"],
+    style: null,
+    tabindex: ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
+    title: null,
+    translate: ["yes", "no"],
+    onclick: null,
+    rel: ["stylesheet", "alternate", "author", "bookmark", "help", "license", "next", "nofollow", "noreferrer", "prefetch", "prev", "search", "tag"]
+  };
+  function populate(obj) {
+    for (var attr in globalAttrs) if (globalAttrs.hasOwnProperty(attr))
+      obj.attrs[attr] = globalAttrs[attr];
+  }
+
+  populate(s);
+  for (var tag in data) if (data.hasOwnProperty(tag) && data[tag] != s)
+    populate(data[tag]);
+
+  CodeMirror.htmlSchema = data;
+  function htmlHint(cm, options) {
+    var local = {schemaInfo: data};
+    if (options) for (var opt in options) local[opt] = options[opt];
+    return CodeMirror.hint.xml(cm, local);
+  }
+  CodeMirror.registerHelper("hint", "html", htmlHint);
+});
diff --git a/src/main/resources/codemirror/addon/hint/javascript-hint.js b/src/main/resources/codemirror/addon/hint/javascript-hint.js
new file mode 100755
index 0000000..7bcbf4a
--- /dev/null
+++ b/src/main/resources/codemirror/addon/hint/javascript-hint.js
@@ -0,0 +1,146 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  var Pos = CodeMirror.Pos;
+
+  function forEach(arr, f) {
+    for (var i = 0, e = arr.length; i < e; ++i) f(arr[i]);
+  }
+
+  function arrayContains(arr, item) {
+    if (!Array.prototype.indexOf) {
+      var i = arr.length;
+      while (i--) {
+        if (arr[i] === item) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return arr.indexOf(item) != -1;
+  }
+
+  function scriptHint(editor, keywords, getToken, options) {
+    // Find the token at the cursor
+    var cur = editor.getCursor(), token = getToken(editor, cur);
+    if (/\b(?:string|comment)\b/.test(token.type)) return;
+    token.state = CodeMirror.innerMode(editor.getMode(), token.state).state;
+
+    // If it's not a 'word-style' token, ignore the token.
+    if (!/^[\w$_]*$/.test(token.string)) {
+      token = {start: cur.ch, end: cur.ch, string: "", state: token.state,
+               type: token.string == "." ? "property" : null};
+    } else if (token.end > cur.ch) {
+      token.end = cur.ch;
+      token.string = token.string.slice(0, cur.ch - token.start);
+    }
+
+    var tprop = token;
+    // If it is a property, find out what it is a property of.
+    while (tprop.type == "property") {
+      tprop = getToken(editor, Pos(cur.line, tprop.start));
+      if (tprop.string != ".") return;
+      tprop = getToken(editor, Pos(cur.line, tprop.start));
+      if (!context) var context = [];
+      context.push(tprop);
+    }
+    return {list: getCompletions(token, context, keywords, options),
+            from: Pos(cur.line, token.start),
+            to: Pos(cur.line, token.end)};
+  }
+
+  function javascriptHint(editor, options) {
+    return scriptHint(editor, javascriptKeywords,
+                      function (e, cur) {return e.getTokenAt(cur);},
+                      options);
+  };
+  CodeMirror.registerHelper("hint", "javascript", javascriptHint);
+
+  function getCoffeeScriptToken(editor, cur) {
+  // This getToken, it is for coffeescript, imitates the behavior of
+  // getTokenAt method in javascript.js, that is, returning "property"
+  // type and treat "." as indepenent token.
+    var token = editor.getTokenAt(cur);
+    if (cur.ch == token.start + 1 && token.string.charAt(0) == '.') {
+      token.end = token.start;
+      token.string = '.';
+      token.type = "property";
+    }
+    else if (/^\.[\w$_]*$/.test(token.string)) {
+      token.type = "property";
+      token.start++;
+      token.string = token.string.replace(/\./, '');
+    }
+    return token;
+  }
+
+  function coffeescriptHint(editor, options) {
+    return scriptHint(editor, coffeescriptKeywords, getCoffeeScriptToken, options);
+  }
+  CodeMirror.registerHelper("hint", "coffeescript", coffeescriptHint);
+
+  var stringProps = ("charAt charCodeAt indexOf lastIndexOf substring substr slice trim trimLeft trimRight " +
+                     "toUpperCase toLowerCase split concat match replace search").split(" ");
+  var arrayProps = ("length concat join splice push pop shift unshift slice reverse sort indexOf " +
+                    "lastIndexOf every some filter forEach map reduce reduceRight ").split(" ");
+  var funcProps = "prototype apply call bind".split(" ");
+  var javascriptKeywords = ("break case catch continue debugger default delete do else false finally for function " +
+                  "if in instanceof new null return switch throw true try typeof var void while with").split(" ");
+  var coffeescriptKeywords = ("and break catch class continue delete do else extends false finally for " +
+                  "if in instanceof isnt new no not null of off on or return switch then throw true try typeof until void while with yes").split(" ");
+
+  function getCompletions(token, context, keywords, options) {
+    var found = [], start = token.string, global = options && options.globalScope || window;
+    function maybeAdd(str) {
+      if (str.lastIndexOf(start, 0) == 0 && !arrayContains(found, str)) found.push(str);
+    }
+    function gatherCompletions(obj) {
+      if (typeof obj == "string") forEach(stringProps, maybeAdd);
+      else if (obj instanceof Array) forEach(arrayProps, maybeAdd);
+      else if (obj instanceof Function) forEach(funcProps, maybeAdd);
+      for (var name in obj) maybeAdd(name);
+    }
+
+    if (context && context.length) {
+      // If this is a property, see if it belongs to some object we can
+      // find in the current environment.
+      var obj = context.pop(), base;
+      if (obj.type && obj.type.indexOf("variable") === 0) {
+        if (options && options.additionalContext)
+          base = options.additionalContext[obj.string];
+        if (!options || options.useGlobalScope !== false)
+          base = base || global[obj.string];
+      } else if (obj.type == "string") {
+        base = "";
+      } else if (obj.type == "atom") {
+        base = 1;
+      } else if (obj.type == "function") {
+        if (global.jQuery != null && (obj.string == '$' || obj.string == 'jQuery') &&
+            (typeof global.jQuery == 'function'))
+          base = global.jQuery();
+        else if (global._ != null && (obj.string == '_') && (typeof global._ == 'function'))
+          base = global._();
+      }
+      while (base != null && context.length)
+        base = base[context.pop().string];
+      if (base != null) gatherCompletions(base);
+    } else {
+      // If not, just look in the global object and any local scope
+      // (reading into JS mode internals to get at the local and global variables)
+      for (var v = token.state.localVars; v; v = v.next) maybeAdd(v.name);
+      for (var v = token.state.globalVars; v; v = v.next) maybeAdd(v.name);
+      if (!options || options.useGlobalScope !== false)
+        gatherCompletions(global);
+      forEach(keywords, maybeAdd);
+    }
+    return found;
+  }
+});
diff --git a/src/main/resources/codemirror/addon/hint/show-hint.css b/src/main/resources/codemirror/addon/hint/show-hint.css
new file mode 100755
index 0000000..924e638
--- /dev/null
+++ b/src/main/resources/codemirror/addon/hint/show-hint.css
@@ -0,0 +1,38 @@
+.CodeMirror-hints {
+  position: absolute;
+  z-index: 10;
+  overflow: hidden;
+  list-style: none;
+
+  margin: 0;
+  padding: 2px;
+
+  -webkit-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+  -moz-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+  box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+  border-radius: 3px;
+  border: 1px solid silver;
+
+  background: white;
+  font-size: 90%;
+  font-family: monospace;
+
+  max-height: 20em;
+  overflow-y: auto;
+}
+
+.CodeMirror-hint {
+  margin: 0;
+  padding: 0 4px;
+  border-radius: 2px;
+  max-width: 19em;
+  overflow: hidden;
+  white-space: pre;
+  color: black;
+  cursor: pointer;
+}
+
+li.CodeMirror-hint-active {
+  background: #08f;
+  color: white;
+}
diff --git a/src/main/resources/codemirror/addon/hint/show-hint.js b/src/main/resources/codemirror/addon/hint/show-hint.js
new file mode 100755
index 0000000..d228fc8
--- /dev/null
+++ b/src/main/resources/codemirror/addon/hint/show-hint.js
@@ -0,0 +1,383 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var HINT_ELEMENT_CLASS        = "CodeMirror-hint";
+  var ACTIVE_HINT_ELEMENT_CLASS = "CodeMirror-hint-active";
+
+  // This is the old interface, kept around for now to stay
+  // backwards-compatible.
+  CodeMirror.showHint = function(cm, getHints, options) {
+    if (!getHints) return cm.showHint(options);
+    if (options && options.async) getHints.async = true;
+    var newOpts = {hint: getHints};
+    if (options) for (var prop in options) newOpts[prop] = options[prop];
+    return cm.showHint(newOpts);
+  };
+
+  CodeMirror.defineExtension("showHint", function(options) {
+    // We want a single cursor position.
+    if (this.listSelections().length > 1 || this.somethingSelected()) return;
+
+    if (this.state.completionActive) this.state.completionActive.close();
+    var completion = this.state.completionActive = new Completion(this, options);
+    if (!completion.options.hint) return;
+
+    CodeMirror.signal(this, "startCompletion", this);
+    completion.update(true);
+  });
+
+  function Completion(cm, options) {
+    this.cm = cm;
+    this.options = this.buildOptions(options);
+    this.widget = null;
+    this.debounce = 0;
+    this.tick = 0;
+    this.startPos = this.cm.getCursor();
+    this.startLen = this.cm.getLine(this.startPos.line).length;
+
+    var self = this;
+    cm.on("cursorActivity", this.activityFunc = function() { self.cursorActivity(); });
+  }
+
+  var requestAnimationFrame = window.requestAnimationFrame || function(fn) {
+    return setTimeout(fn, 1000/60);
+  };
+  var cancelAnimationFrame = window.cancelAnimationFrame || clearTimeout;
+
+  Completion.prototype = {
+    close: function() {
+      if (!this.active()) return;
+      this.cm.state.completionActive = null;
+      this.tick = null;
+      this.cm.off("cursorActivity", this.activityFunc);
+
+      if (this.widget && this.data) CodeMirror.signal(this.data, "close");
+      if (this.widget) this.widget.close();
+      CodeMirror.signal(this.cm, "endCompletion", this.cm);
+    },
+
+    active: function() {
+      return this.cm.state.completionActive == this;
+    },
+
+    pick: function(data, i) {
+      var completion = data.list[i];
+      if (completion.hint) completion.hint(this.cm, data, completion);
+      else this.cm.replaceRange(getText(completion), completion.from || data.from,
+                                completion.to || data.to, "complete");
+      CodeMirror.signal(data, "pick", completion);
+      this.close();
+    },
+
+    cursorActivity: function() {
+      if (this.debounce) {
+        cancelAnimationFrame(this.debounce);
+        this.debounce = 0;
+      }
+
+      var pos = this.cm.getCursor(), line = this.cm.getLine(pos.line);
+      if (pos.line != this.startPos.line || line.length - pos.ch != this.startLen - this.startPos.ch ||
+          pos.ch < this.startPos.ch || this.cm.somethingSelected() ||
+          (pos.ch && this.options.closeCharacters.test(line.charAt(pos.ch - 1)))) {
+        this.close();
+      } else {
+        var self = this;
+        this.debounce = requestAnimationFrame(function() {self.update();});
+        if (this.widget) this.widget.disable();
+      }
+    },
+
+    update: function(first) {
+      if (this.tick == null) return;
+      if (this.data) CodeMirror.signal(this.data, "update");
+      if (!this.options.hint.async) {
+        this.finishUpdate(this.options.hint(this.cm, this.options), first);
+      } else {
+        var myTick = ++this.tick, self = this;
+        this.options.hint(this.cm, function(data) {
+          if (self.tick == myTick) self.finishUpdate(data, first);
+        }, this.options);
+      }
+    },
+
+    finishUpdate: function(data, first) {
+      this.data = data;
+
+      var picked = (this.widget && this.widget.picked) || (first && this.options.completeSingle);
+      if (this.widget) this.widget.close();
+      if (data && data.list.length) {
+        if (picked && data.list.length == 1) {
+          this.pick(data, 0);
+        } else {
+          this.widget = new Widget(this, data);
+          CodeMirror.signal(data, "shown");
+        }
+      }
+    },
+
+    buildOptions: function(options) {
+      var editor = this.cm.options.hintOptions;
+      var out = {};
+      for (var prop in defaultOptions) out[prop] = defaultOptions[prop];
+      if (editor) for (var prop in editor)
+        if (editor[prop] !== undefined) out[prop] = editor[prop];
+      if (options) for (var prop in options)
+        if (options[prop] !== undefined) out[prop] = options[prop];
+      return out;
+    }
+  };
+
+  function getText(completion) {
+    if (typeof completion == "string") return completion;
+    else return completion.text;
+  }
+
+  function buildKeyMap(completion, handle) {
+    var baseMap = {
+      Up: function() {handle.moveFocus(-1);},
+      Down: function() {handle.moveFocus(1);},
+      PageUp: function() {handle.moveFocus(-handle.menuSize() + 1, true);},
+      PageDown: function() {handle.moveFocus(handle.menuSize() - 1, true);},
+      Home: function() {handle.setFocus(0);},
+      End: function() {handle.setFocus(handle.length - 1);},
+      Enter: handle.pick,
+      Tab: handle.pick,
+      Esc: handle.close
+    };
+    var custom = completion.options.customKeys;
+    var ourMap = custom ? {} : baseMap;
+    function addBinding(key, val) {
+      var bound;
+      if (typeof val != "string")
+        bound = function(cm) { return val(cm, handle); };
+      // This mechanism is deprecated
+      else if (baseMap.hasOwnProperty(val))
+        bound = baseMap[val];
+      else
+        bound = val;
+      ourMap[key] = bound;
+    }
+    if (custom)
+      for (var key in custom) if (custom.hasOwnProperty(key))
+        addBinding(key, custom[key]);
+    var extra = completion.options.extraKeys;
+    if (extra)
+      for (var key in extra) if (extra.hasOwnProperty(key))
+        addBinding(key, extra[key]);
+    return ourMap;
+  }
+
+  function getHintElement(hintsElement, el) {
+    while (el && el != hintsElement) {
+      if (el.nodeName.toUpperCase() === "LI" && el.parentNode == hintsElement) return el;
+      el = el.parentNode;
+    }
+  }
+
+  function Widget(completion, data) {
+    this.completion = completion;
+    this.data = data;
+    this.picked = false;
+    var widget = this, cm = completion.cm;
+
+    var hints = this.hints = document.createElement("ul");
+    hints.className = "CodeMirror-hints";
+    this.selectedHint = data.selectedHint || 0;
+
+    var completions = data.list;
+    for (var i = 0; i < completions.length; ++i) {
+      var elt = hints.appendChild(document.createElement("li")), cur = completions[i];
+      var className = HINT_ELEMENT_CLASS + (i != this.selectedHint ? "" : " " + ACTIVE_HINT_ELEMENT_CLASS);
+      if (cur.className != null) className = cur.className + " " + className;
+      elt.className = className;
+      if (cur.render) cur.render(elt, data, cur);
+      else elt.appendChild(document.createTextNode(cur.displayText || getText(cur)));
+      elt.hintId = i;
+    }
+
+    var pos = cm.cursorCoords(completion.options.alignWithWord ? data.from : null);
+    var left = pos.left, top = pos.bottom, below = true;
+    hints.style.left = left + "px";
+    hints.style.top = top + "px";
+    // If we're at the edge of the screen, then we want the menu to appear on the left of the cursor.
+    var winW = window.innerWidth || Math.max(document.body.offsetWidth, document.documentElement.offsetWidth);
+    var winH = window.innerHeight || Math.max(document.body.offsetHeight, document.documentElement.offsetHeight);
+    (completion.options.container || document.body).appendChild(hints);
+    var box = hints.getBoundingClientRect(), overlapY = box.bottom - winH;
+    if (overlapY > 0) {
+      var height = box.bottom - box.top, curTop = pos.top - (pos.bottom - box.top);
+      if (curTop - height > 0) { // Fits above cursor
+        hints.style.top = (top = pos.top - height) + "px";
+        below = false;
+      } else if (height > winH) {
+        hints.style.height = (winH - 5) + "px";
+        hints.style.top = (top = pos.bottom - box.top) + "px";
+        var cursor = cm.getCursor();
+        if (data.from.ch != cursor.ch) {
+          pos = cm.cursorCoords(cursor);
+          hints.style.left = (left = pos.left) + "px";
+          box = hints.getBoundingClientRect();
+        }
+      }
+    }
+    var overlapX = box.right - winW;
+    if (overlapX > 0) {
+      if (box.right - box.left > winW) {
+        hints.style.width = (winW - 5) + "px";
+        overlapX -= (box.right - box.left) - winW;
+      }
+      hints.style.left = (left = pos.left - overlapX) + "px";
+    }
+
+    cm.addKeyMap(this.keyMap = buildKeyMap(completion, {
+      moveFocus: function(n, avoidWrap) { widget.changeActive(widget.selectedHint + n, avoidWrap); },
+      setFocus: function(n) { widget.changeActive(n); },
+      menuSize: function() { return widget.screenAmount(); },
+      length: completions.length,
+      close: function() { completion.close(); },
+      pick: function() { widget.pick(); },
+      data: data
+    }));
+
+    if (completion.options.closeOnUnfocus) {
+      var closingOnBlur;
+      cm.on("blur", this.onBlur = function() { closingOnBlur = setTimeout(function() { completion.close(); }, 100); });
+      cm.on("focus", this.onFocus = function() { clearTimeout(closingOnBlur); });
+    }
+
+    var startScroll = cm.getScrollInfo();
+    cm.on("scroll", this.onScroll = function() {
+      var curScroll = cm.getScrollInfo(), editor = cm.getWrapperElement().getBoundingClientRect();
+      var newTop = top + startScroll.top - curScroll.top;
+      var point = newTop - (window.pageYOffset || (document.documentElement || document.body).scrollTop);
+      if (!below) point += hints.offsetHeight;
+      if (point <= editor.top || point >= editor.bottom) return completion.close();
+      hints.style.top = newTop + "px";
+      hints.style.left = (left + startScroll.left - curScroll.left) + "px";
+    });
+
+    CodeMirror.on(hints, "dblclick", function(e) {
+      var t = getHintElement(hints, e.target || e.srcElement);
+      if (t && t.hintId != null) {widget.changeActive(t.hintId); widget.pick();}
+    });
+
+    CodeMirror.on(hints, "click", function(e) {
+      var t = getHintElement(hints, e.target || e.srcElement);
+      if (t && t.hintId != null) {
+        widget.changeActive(t.hintId);
+        if (completion.options.completeOnSingleClick) widget.pick();
+      }
+    });
+
+    CodeMirror.on(hints, "mousedown", function() {
+      setTimeout(function(){cm.focus();}, 20);
+    });
+
+    CodeMirror.signal(data, "select", completions[0], hints.firstChild);
+    return true;
+  }
+
+  Widget.prototype = {
+    close: function() {
+      if (this.completion.widget != this) return;
+      this.completion.widget = null;
+      this.hints.parentNode.removeChild(this.hints);
+      this.completion.cm.removeKeyMap(this.keyMap);
+
+      var cm = this.completion.cm;
+      if (this.completion.options.closeOnUnfocus) {
+        cm.off("blur", this.onBlur);
+        cm.off("focus", this.onFocus);
+      }
+      cm.off("scroll", this.onScroll);
+    },
+
+    disable: function() {
+      this.completion.cm.removeKeyMap(this.keyMap);
+      var widget = this;
+      this.keyMap = {Enter: function() { widget.picked = true; }};
+      this.completion.cm.addKeyMap(this.keyMap);
+    },
+
+    pick: function() {
+      this.completion.pick(this.data, this.selectedHint);
+    },
+
+    changeActive: function(i, avoidWrap) {
+      if (i >= this.data.list.length)
+        i = avoidWrap ? this.data.list.length - 1 : 0;
+      else if (i < 0)
+        i = avoidWrap ? 0  : this.data.list.length - 1;
+      if (this.selectedHint == i) return;
+      var node = this.hints.childNodes[this.selectedHint];
+      node.className = node.className.replace(" " + ACTIVE_HINT_ELEMENT_CLASS, "");
+      node = this.hints.childNodes[this.selectedHint = i];
+      node.className += " " + ACTIVE_HINT_ELEMENT_CLASS;
+      if (node.offsetTop < this.hints.scrollTop)
+        this.hints.scrollTop = node.offsetTop - 3;
+      else if (node.offsetTop + node.offsetHeight > this.hints.scrollTop + this.hints.clientHeight)
+        this.hints.scrollTop = node.offsetTop + node.offsetHeight - this.hints.clientHeight + 3;
+      CodeMirror.signal(this.data, "select", this.data.list[this.selectedHint], node);
+    },
+
+    screenAmount: function() {
+      return Math.floor(this.hints.clientHeight / this.hints.firstChild.offsetHeight) || 1;
+    }
+  };
+
+  CodeMirror.registerHelper("hint", "auto", function(cm, options) {
+    var helpers = cm.getHelpers(cm.getCursor(), "hint"), words;
+    if (helpers.length) {
+      for (var i = 0; i < helpers.length; i++) {
+        var cur = helpers[i](cm, options);
+        if (cur && cur.list.length) return cur;
+      }
+    } else if (words = cm.getHelper(cm.getCursor(), "hintWords")) {
+      if (words) return CodeMirror.hint.fromList(cm, {words: words});
+    } else if (CodeMirror.hint.anyword) {
+      return CodeMirror.hint.anyword(cm, options);
+    }
+  });
+
+  CodeMirror.registerHelper("hint", "fromList", function(cm, options) {
+    var cur = cm.getCursor(), token = cm.getTokenAt(cur);
+    var found = [];
+    for (var i = 0; i < options.words.length; i++) {
+      var word = options.words[i];
+      if (word.slice(0, token.string.length) == token.string)
+        found.push(word);
+    }
+
+    if (found.length) return {
+      list: found,
+      from: CodeMirror.Pos(cur.line, token.start),
+            to: CodeMirror.Pos(cur.line, token.end)
+    };
+  });
+
+  CodeMirror.commands.autocomplete = CodeMirror.showHint;
+
+  var defaultOptions = {
+    hint: CodeMirror.hint.auto,
+    completeSingle: true,
+    alignWithWord: true,
+    closeCharacters: /[\s()\[\]{};:>,]/,
+    closeOnUnfocus: true,
+    completeOnSingleClick: false,
+    container: null,
+    customKeys: null,
+    extraKeys: null
+  };
+
+  CodeMirror.defineOption("hintOptions", null);
+});
diff --git a/src/main/resources/codemirror/addon/hint/sql-hint.js b/src/main/resources/codemirror/addon/hint/sql-hint.js
new file mode 100755
index 0000000..22124b5
--- /dev/null
+++ b/src/main/resources/codemirror/addon/hint/sql-hint.js
@@ -0,0 +1,254 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("../../mode/sql/sql"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "../../mode/sql/sql"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var tables;
+  var defaultTable;
+  var keywords;
+  var CONS = {
+    QUERY_DIV: ";",
+    ALIAS_KEYWORD: "AS"
+  };
+  var Pos = CodeMirror.Pos;
+
+  function getKeywords(editor) {
+    var mode = editor.doc.modeOption;
+    if (mode === "sql") mode = "text/x-sql";
+    return CodeMirror.resolveMode(mode).keywords;
+  }
+
+  function getText(item) {
+    return typeof item == "string" ? item : item.text;
+  }
+
+  function getItem(list, item) {
+    if (!list.slice) return list[item];
+    for (var i = list.length - 1; i >= 0; i--) if (getText(list[i]) == item)
+      return list[i];
+  }
+
+  function shallowClone(object) {
+    var result = {};
+    for (var key in object) if (object.hasOwnProperty(key))
+      result[key] = object[key];
+    return result;
+  }
+
+  function match(string, word) {
+    var len = string.length;
+    var sub = getText(word).substr(0, len);
+    return string.toUpperCase() === sub.toUpperCase();
+  }
+
+  function addMatches(result, search, wordlist, formatter) {
+    for (var word in wordlist) {
+      if (!wordlist.hasOwnProperty(word)) continue;
+      if (wordlist.slice) word = wordlist[word];
+
+      if (match(search, word)) result.push(formatter(word));
+    }
+  }
+
+  function cleanName(name) {
+    // Get rid name from backticks(`) and preceding dot(.)
+    if (name.charAt(0) == ".") {
+      name = name.substr(1);
+    }
+    return name.replace(/`/g, "");
+  }
+
+  function insertBackticks(name) {
+    var nameParts = getText(name).split(".");
+    for (var i = 0; i < nameParts.length; i++)
+      nameParts[i] = "`" + nameParts[i] + "`";
+    var escaped = nameParts.join(".");
+    if (typeof name == "string") return escaped;
+    name = shallowClone(name);
+    name.text = escaped;
+    return name;
+  }
+
+  function nameCompletion(cur, token, result, editor) {
+    // Try to complete table, colunm names and return start position of completion
+    var useBacktick = false;
+    var nameParts = [];
+    var start = token.start;
+    var cont = true;
+    while (cont) {
+      cont = (token.string.charAt(0) == ".");
+      useBacktick = useBacktick || (token.string.charAt(0) == "`");
+
+      start = token.start;
+      nameParts.unshift(cleanName(token.string));
+
+      token = editor.getTokenAt(Pos(cur.line, token.start));
+      if (token.string == ".") {
+        cont = true;
+        token = editor.getTokenAt(Pos(cur.line, token.start));
+      }
+    }
+
+    // Try to complete table names
+    var string = nameParts.join(".");
+    addMatches(result, string, tables, function(w) {
+      return useBacktick ? insertBackticks(w) : w;
+    });
+
+    // Try to complete columns from defaultTable
+    addMatches(result, string, defaultTable, function(w) {
+      return useBacktick ? insertBackticks(w) : w;
+    });
+
+    // Try to complete columns
+    string = nameParts.pop();
+    var table = nameParts.join(".");
+
+    var alias = false;
+    var aliasTable = table;
+    // Check if table is available. If not, find table by Alias
+    if (!getItem(tables, table)) {
+      var oldTable = table;
+      table = findTableByAlias(table, editor);
+      if (table !== oldTable) alias = true;
+    }
+
+    var columns = getItem(tables, table);
+    if (columns && columns.columns)
+      columns = columns.columns;
+
+    if (columns) {
+      addMatches(result, string, columns, function(w) {
+        var tableInsert = table;
+        if (alias == true) tableInsert = aliasTable;
+        if (typeof w == "string") {
+          w = tableInsert + "." + w;
+        } else {
+          w = shallowClone(w);
+          w.text = tableInsert + "." + w.text;
+        }
+        return useBacktick ? insertBackticks(w) : w;
+      });
+    }
+
+    return start;
+  }
+
+  function eachWord(lineText, f) {
+    if (!lineText) return;
+    var excepted = /[,;]/g;
+    var words = lineText.split(" ");
+    for (var i = 0; i < words.length; i++) {
+      f(words[i]?words[i].replace(excepted, '') : '');
+    }
+  }
+
+  function convertCurToNumber(cur) {
+    // max characters of a line is 999,999.
+    return cur.line + cur.ch / Math.pow(10, 6);
+  }
+
+  function convertNumberToCur(num) {
+    return Pos(Math.floor(num), +num.toString().split('.').pop());
+  }
+
+  function findTableByAlias(alias, editor) {
+    var doc = editor.doc;
+    var fullQuery = doc.getValue();
+    var aliasUpperCase = alias.toUpperCase();
+    var previousWord = "";
+    var table = "";
+    var separator = [];
+    var validRange = {
+      start: Pos(0, 0),
+      end: Pos(editor.lastLine(), editor.getLineHandle(editor.lastLine()).length)
+    };
+
+    //add separator
+    var indexOfSeparator = fullQuery.indexOf(CONS.QUERY_DIV);
+    while(indexOfSeparator != -1) {
+      separator.push(doc.posFromIndex(indexOfSeparator));
+      indexOfSeparator = fullQuery.indexOf(CONS.QUERY_DIV, indexOfSeparator+1);
+    }
+    separator.unshift(Pos(0, 0));
+    separator.push(Pos(editor.lastLine(), editor.getLineHandle(editor.lastLine()).text.length));
+
+    //find valid range
+    var prevItem = 0;
+    var current = convertCurToNumber(editor.getCursor());
+    for (var i=0; i< separator.length; i++) {
+      var _v = convertCurToNumber(separator[i]);
+      if (current > prevItem && current <= _v) {
+        validRange = { start: convertNumberToCur(prevItem), end: convertNumberToCur(_v) };
+        break;
+      }
+      prevItem = _v;
+    }
+
+    var query = doc.getRange(validRange.start, validRange.end, false);
+
+    for (var i = 0; i < query.length; i++) {
+      var lineText = query[i];
+      eachWord(lineText, function(word) {
+        var wordUpperCase = word.toUpperCase();
+        if (wordUpperCase === aliasUpperCase && getItem(tables, previousWord))
+          table = previousWord;
+        if (wordUpperCase !== CONS.ALIAS_KEYWORD)
+          previousWord = word;
+      });
+      if (table) break;
+    }
+    return table;
+  }
+
+  CodeMirror.registerHelper("hint", "sql", function(editor, options) {
+    tables = (options && options.tables) || {};
+    var defaultTableName = options && options.defaultTable;
+    var disableKeywords = options && options.disableKeywords;
+    defaultTable = defaultTableName && getItem(tables, defaultTableName);
+    keywords = keywords || getKeywords(editor);
+
+    if (defaultTableName && !defaultTable)
+      defaultTable = findTableByAlias(defaultTableName, editor);
+
+    defaultTable = defaultTable || [];
+
+    if (defaultTable.columns)
+      defaultTable = defaultTable.columns;
+
+    var cur = editor.getCursor();
+    var result = [];
+    var token = editor.getTokenAt(cur), start, end, search;
+    if (token.end > cur.ch) {
+      token.end = cur.ch;
+      token.string = token.string.slice(0, cur.ch - token.start);
+    }
+
+    if (token.string.match(/^[.`\w@]\w*$/)) {
+      search = token.string;
+      start = token.start;
+      end = token.end;
+    } else {
+      start = end = cur.ch;
+      search = "";
+    }
+    if (search.charAt(0) == "." || search.charAt(0) == "`") {
+      start = nameCompletion(cur, token, result, editor);
+    } else {
+      addMatches(result, search, tables, function(w) {return w;});
+      addMatches(result, search, defaultTable, function(w) {return w;});
+      if (!disableKeywords)
+        addMatches(result, search, keywords, function(w) {return w.toUpperCase();});
+    }
+
+    return {list: result, from: Pos(cur.line, start), to: Pos(cur.line, end)};
+  });
+});
diff --git a/src/main/resources/codemirror/addon/hint/xml-hint.js b/src/main/resources/codemirror/addon/hint/xml-hint.js
new file mode 100755
index 0000000..9b9baa0
--- /dev/null
+++ b/src/main/resources/codemirror/addon/hint/xml-hint.js
@@ -0,0 +1,110 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var Pos = CodeMirror.Pos;
+
+  function getHints(cm, options) {
+    var tags = options && options.schemaInfo;
+    var quote = (options && options.quoteChar) || '"';
+    if (!tags) return;
+    var cur = cm.getCursor(), token = cm.getTokenAt(cur);
+    if (token.end > cur.ch) {
+      token.end = cur.ch;
+      token.string = token.string.slice(0, cur.ch - token.start);
+    }
+    var inner = CodeMirror.innerMode(cm.getMode(), token.state);
+    if (inner.mode.name != "xml") return;
+    var result = [], replaceToken = false, prefix;
+    var tag = /\btag\b/.test(token.type) && !/>$/.test(token.string);
+    var tagName = tag && /^\w/.test(token.string), tagStart;
+
+    if (tagName) {
+      var before = cm.getLine(cur.line).slice(Math.max(0, token.start - 2), token.start);
+      var tagType = /<\/$/.test(before) ? "close" : /<$/.test(before) ? "open" : null;
+      if (tagType) tagStart = token.start - (tagType == "close" ? 2 : 1);
+    } else if (tag && token.string == "<") {
+      tagType = "open";
+    } else if (tag && token.string == "</") {
+      tagType = "close";
+    }
+
+    if (!tag && !inner.state.tagName || tagType) {
+      if (tagName)
+        prefix = token.string;
+      replaceToken = tagType;
+      var cx = inner.state.context, curTag = cx && tags[cx.tagName];
+      var childList = cx ? curTag && curTag.children : tags["!top"];
+      if (childList && tagType != "close") {
+        for (var i = 0; i < childList.length; ++i) if (!prefix || childList[i].lastIndexOf(prefix, 0) == 0)
+          result.push("<" + childList[i]);
+      } else if (tagType != "close") {
+        for (var name in tags)
+          if (tags.hasOwnProperty(name) && name != "!top" && name != "!attrs" && (!prefix || name.lastIndexOf(prefix, 0) == 0))
+            result.push("<" + name);
+      }
+      if (cx && (!prefix || tagType == "close" && cx.tagName.lastIndexOf(prefix, 0) == 0))
+        result.push("</" + cx.tagName + ">");
+    } else {
+      // Attribute completion
+      var curTag = tags[inner.state.tagName], attrs = curTag && curTag.attrs;
+      var globalAttrs = tags["!attrs"];
+      if (!attrs && !globalAttrs) return;
+      if (!attrs) {
+        attrs = globalAttrs;
+      } else if (globalAttrs) { // Combine tag-local and global attributes
+        var set = {};
+        for (var nm in globalAttrs) if (globalAttrs.hasOwnProperty(nm)) set[nm] = globalAttrs[nm];
+        for (var nm in attrs) if (attrs.hasOwnProperty(nm)) set[nm] = attrs[nm];
+        attrs = set;
+      }
+      if (token.type == "string" || token.string == "=") { // A value
+        var before = cm.getRange(Pos(cur.line, Math.max(0, cur.ch - 60)),
+                                 Pos(cur.line, token.type == "string" ? token.start : token.end));
+        var atName = before.match(/([^\s\u00a0=<>\"\']+)=$/), atValues;
+        if (!atName || !attrs.hasOwnProperty(atName[1]) || !(atValues = attrs[atName[1]])) return;
+        if (typeof atValues == 'function') atValues = atValues.call(this, cm); // Functions can be used to supply values for autocomplete widget
+        if (token.type == "string") {
+          prefix = token.string;
+          var n = 0;
+          if (/['"]/.test(token.string.charAt(0))) {
+            quote = token.string.charAt(0);
+            prefix = token.string.slice(1);
+            n++;
+          }
+          var len = token.string.length;
+          if (/['"]/.test(token.string.charAt(len - 1))) {
+            quote = token.string.charAt(len - 1);
+            prefix = token.string.substr(n, len - 2);
+          }
+          replaceToken = true;
+        }
+        for (var i = 0; i < atValues.length; ++i) if (!prefix || atValues[i].lastIndexOf(prefix, 0) == 0)
+          result.push(quote + atValues[i] + quote);
+      } else { // An attribute name
+        if (token.type == "attribute") {
+          prefix = token.string;
+          replaceToken = true;
+        }
+        for (var attr in attrs) if (attrs.hasOwnProperty(attr) && (!prefix || attr.lastIndexOf(prefix, 0) == 0))
+          result.push(attr);
+      }
+    }
+    return {
+      list: result,
+      from: replaceToken ? Pos(cur.line, tagStart == null ? token.start : tagStart) : cur,
+      to: replaceToken ? Pos(cur.line, token.end) : cur
+    };
+  }
+
+  CodeMirror.registerHelper("hint", "xml", getHints);
+});
diff --git a/src/main/resources/codemirror/addon/lint/coffeescript-lint.js b/src/main/resources/codemirror/addon/lint/coffeescript-lint.js
new file mode 100755
index 0000000..7e39428
--- /dev/null
+++ b/src/main/resources/codemirror/addon/lint/coffeescript-lint.js
@@ -0,0 +1,41 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Depends on coffeelint.js from http://www.coffeelint.org/js/coffeelint.js
+
+// declare global: coffeelint
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.registerHelper("lint", "coffeescript", function(text) {
+  var found = [];
+  var parseError = function(err) {
+    var loc = err.lineNumber;
+    found.push({from: CodeMirror.Pos(loc-1, 0),
+                to: CodeMirror.Pos(loc, 0),
+                severity: err.level,
+                message: err.message});
+  };
+  try {
+    var res = coffeelint.lint(text);
+    for(var i = 0; i < res.length; i++) {
+      parseError(res[i]);
+    }
+  } catch(e) {
+    found.push({from: CodeMirror.Pos(e.location.first_line, 0),
+                to: CodeMirror.Pos(e.location.last_line, e.location.last_column),
+                severity: 'error',
+                message: e.message});
+  }
+  return found;
+});
+
+});
diff --git a/src/main/resources/codemirror/addon/lint/css-lint.js b/src/main/resources/codemirror/addon/lint/css-lint.js
new file mode 100755
index 0000000..1f61b47
--- /dev/null
+++ b/src/main/resources/codemirror/addon/lint/css-lint.js
@@ -0,0 +1,35 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Depends on csslint.js from https://github.com/stubbornella/csslint
+
+// declare global: CSSLint
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.registerHelper("lint", "css", function(text) {
+  var found = [];
+  if (!window.CSSLint) return found;
+  var results = CSSLint.verify(text), messages = results.messages, message = null;
+  for ( var i = 0; i < messages.length; i++) {
+    message = messages[i];
+    var startLine = message.line -1, endLine = message.line -1, startCol = message.col -1, endCol = message.col;
+    found.push({
+      from: CodeMirror.Pos(startLine, startCol),
+      to: CodeMirror.Pos(endLine, endCol),
+      message: message.message,
+      severity : message.type
+    });
+  }
+  return found;
+});
+
+});
diff --git a/src/main/resources/codemirror/addon/lint/javascript-lint.js b/src/main/resources/codemirror/addon/lint/javascript-lint.js
new file mode 100755
index 0000000..d4f2ae9
--- /dev/null
+++ b/src/main/resources/codemirror/addon/lint/javascript-lint.js
@@ -0,0 +1,136 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+  // declare global: JSHINT
+
+  var bogus = [ "Dangerous comment" ];
+
+  var warnings = [ [ "Expected '{'",
+                     "Statement body should be inside '{ }' braces." ] ];
+
+  var errors = [ "Missing semicolon", "Extra comma", "Missing property name",
+                 "Unmatched ", " and instead saw", " is not defined",
+                 "Unclosed string", "Stopping, unable to continue" ];
+
+  function validator(text, options) {
+    if (!window.JSHINT) return [];
+    JSHINT(text, options, options.globals);
+    var errors = JSHINT.data().errors, result = [];
+    if (errors) parseErrors(errors, result);
+    return result;
+  }
+
+  CodeMirror.registerHelper("lint", "javascript", validator);
+
+  function cleanup(error) {
+    // All problems are warnings by default
+    fixWith(error, warnings, "warning", true);
+    fixWith(error, errors, "error");
+
+    return isBogus(error) ? null : error;
+  }
+
+  function fixWith(error, fixes, severity, force) {
+    var description, fix, find, replace, found;
+
+    description = error.description;
+
+    for ( var i = 0; i < fixes.length; i++) {
+      fix = fixes[i];
+      find = (typeof fix === "string" ? fix : fix[0]);
+      replace = (typeof fix === "string" ? null : fix[1]);
+      found = description.indexOf(find) !== -1;
+
+      if (force || found) {
+        error.severity = severity;
+      }
+      if (found && replace) {
+        error.description = replace;
+      }
+    }
+  }
+
+  function isBogus(error) {
+    var description = error.description;
+    for ( var i = 0; i < bogus.length; i++) {
+      if (description.indexOf(bogus[i]) !== -1) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function parseErrors(errors, output) {
+    for ( var i = 0; i < errors.length; i++) {
+      var error = errors[i];
+      if (error) {
+        var linetabpositions, index;
+
+        linetabpositions = [];
+
+        // This next block is to fix a problem in jshint. Jshint
+        // replaces
+        // all tabs with spaces then performs some checks. The error
+        // positions (character/space) are then reported incorrectly,
+        // not taking the replacement step into account. Here we look
+        // at the evidence line and try to adjust the character position
+        // to the correct value.
+        if (error.evidence) {
+          // Tab positions are computed once per line and cached
+          var tabpositions = linetabpositions[error.line];
+          if (!tabpositions) {
+            var evidence = error.evidence;
+            tabpositions = [];
+            // ugggh phantomjs does not like this
+            // forEachChar(evidence, function(item, index) {
+            Array.prototype.forEach.call(evidence, function(item,
+                                                            index) {
+              if (item === '\t') {
+                // First col is 1 (not 0) to match error
+                // positions
+                tabpositions.push(index + 1);
+              }
+            });
+            linetabpositions[error.line] = tabpositions;
+          }
+          if (tabpositions.length > 0) {
+            var pos = error.character;
+            tabpositions.forEach(function(tabposition) {
+              if (pos > tabposition) pos -= 1;
+            });
+            error.character = pos;
+          }
+        }
+
+        var start = error.character - 1, end = start + 1;
+        if (error.evidence) {
+          index = error.evidence.substring(start).search(/.\b/);
+          if (index > -1) {
+            end += index;
+          }
+        }
+
+        // Convert to format expected by validation service
+        error.description = error.reason;// + "(jshint)";
+        error.start = error.character;
+        error.end = end;
+        error = cleanup(error);
+
+        if (error)
+          output.push({message: error.description,
+                       severity: error.severity,
+                       from: CodeMirror.Pos(error.line - 1, start),
+                       to: CodeMirror.Pos(error.line - 1, end)});
+      }
+    }
+  }
+});
diff --git a/src/main/resources/codemirror/addon/lint/json-lint.js b/src/main/resources/codemirror/addon/lint/json-lint.js
new file mode 100755
index 0000000..9dbb616
--- /dev/null
+++ b/src/main/resources/codemirror/addon/lint/json-lint.js
@@ -0,0 +1,31 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Depends on jsonlint.js from https://github.com/zaach/jsonlint
+
+// declare global: jsonlint
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.registerHelper("lint", "json", function(text) {
+  var found = [];
+  jsonlint.parseError = function(str, hash) {
+    var loc = hash.loc;
+    found.push({from: CodeMirror.Pos(loc.first_line - 1, loc.first_column),
+                to: CodeMirror.Pos(loc.last_line - 1, loc.last_column),
+                message: str});
+  };
+  try { jsonlint.parse(text); }
+  catch(e) {}
+  return found;
+});
+
+});
diff --git a/src/main/resources/codemirror/addon/lint/lint.css b/src/main/resources/codemirror/addon/lint/lint.css
new file mode 100755
index 0000000..414a9a0
--- /dev/null
+++ b/src/main/resources/codemirror/addon/lint/lint.css
@@ -0,0 +1,73 @@
+/* The lint marker gutter */
+.CodeMirror-lint-markers {
+  width: 16px;
+}
+
+.CodeMirror-lint-tooltip {
+  background-color: infobackground;
+  border: 1px solid black;
+  border-radius: 4px 4px 4px 4px;
+  color: infotext;
+  font-family: monospace;
+  font-size: 10pt;
+  overflow: hidden;
+  padding: 2px 5px;
+  position: fixed;
+  white-space: pre;
+  white-space: pre-wrap;
+  z-index: 100;
+  max-width: 600px;
+  opacity: 0;
+  transition: opacity .4s;
+  -moz-transition: opacity .4s;
+  -webkit-transition: opacity .4s;
+  -o-transition: opacity .4s;
+  -ms-transition: opacity .4s;
+}
+
+.CodeMirror-lint-mark-error, .CodeMirror-lint-mark-warning {
+  background-position: left bottom;
+  background-repeat: repeat-x;
+}
+
+.CodeMirror-lint-mark-error {
+  background-image:
+  url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJDw4cOCW1/KIAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAHElEQVQI12NggIL/DAz/GdA5/xkY/qPKMDAwAADLZwf5rvm+LQAAAABJRU5ErkJggg==")
+  ;
+}
+
+.CodeMirror-lint-mark-warning {
+  background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJFhQXEbhTg7YAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAMklEQVQI12NkgIIvJ3QXMjAwdDN+OaEbysDA4MPAwNDNwMCwiOHLCd1zX07o6kBVGQEAKBANtobskNMAAAAASUVORK5CYII=");
+}
+
+.CodeMirror-lint-marker-error, .CodeMirror-lint-marker-warning {
+  background-position: center center;
+  background-repeat: no-repeat;
+  cursor: pointer;
+  display: inline-block;
+  height: 16px;
+  width: 16px;
+  vertical-align: middle;
+  position: relative;
+}
+
+.CodeMirror-lint-message-error, .CodeMirror-lint-message-warning {
+  padding-left: 18px;
+  background-position: top left;
+  background-repeat: no-repeat;
+}
+
+.CodeMirror-lint-marker-error, .CodeMirror-lint-message-error {
+  background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAHlBMVEW7AAC7AACxAAC7AAC7AAAAAAC4AAC5AAD///+7AAAUdclpAAAABnRSTlMXnORSiwCK0ZKSAAAATUlEQVR42mWPOQ7AQAgDuQLx/z8csYRmPRIFIwRGnosRrpamvkKi0FTIiMASR3hhKW+hAN6/tIWhu9PDWiTGNEkTtIOucA5Oyr9ckPgAWm0GPBog6v4AAAAASUVORK5CYII=");
+}
+
+.CodeMirror-lint-marker-warning, .CodeMirror-lint-message-warning {
+  background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAANlBMVEX/uwDvrwD/uwD/uwD/uwD/uwD/uwD/uwD/uwD6twD/uwAAAADurwD2tQD7uAD+ugAAAAD/uwDhmeTRAAAADHRSTlMJ8mN1EYcbmiixgACm7WbuAAAAVklEQVR42n3PUQqAIBBFUU1LLc3u/jdbOJoW1P08DA9Gba8+YWJ6gNJoNYIBzAA2chBth5kLmG9YUoG0NHAUwFXwO9LuBQL1giCQb8gC9Oro2vp5rncCIY8L8uEx5ZkAAAAASUVORK5CYII=");
+}
+
+.CodeMirror-lint-marker-multiple {
+  background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAcAAAAHCAMAAADzjKfhAAAACVBMVEUAAAAAAAC/v7914kyHAAAAAXRSTlMAQObYZgAAACNJREFUeNo1ioEJAAAIwmz/H90iFFSGJgFMe3gaLZ0od+9/AQZ0ADosbYraAAAAAElFTkSuQmCC");
+  background-repeat: no-repeat;
+  background-position: right bottom;
+  width: 100%; height: 100%;
+}
diff --git a/src/main/resources/codemirror/addon/lint/lint.js b/src/main/resources/codemirror/addon/lint/lint.js
new file mode 100755
index 0000000..3eea203
--- /dev/null
+++ b/src/main/resources/codemirror/addon/lint/lint.js
@@ -0,0 +1,207 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+  var GUTTER_ID = "CodeMirror-lint-markers";
+
+  function showTooltip(e, content) {
+    var tt = document.createElement("div");
+    tt.className = "CodeMirror-lint-tooltip";
+    tt.appendChild(content.cloneNode(true));
+    document.body.appendChild(tt);
+
+    function position(e) {
+      if (!tt.parentNode) return CodeMirror.off(document, "mousemove", position);
+      tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px";
+      tt.style.left = (e.clientX + 5) + "px";
+    }
+    CodeMirror.on(document, "mousemove", position);
+    position(e);
+    if (tt.style.opacity != null) tt.style.opacity = 1;
+    return tt;
+  }
+  function rm(elt) {
+    if (elt.parentNode) elt.parentNode.removeChild(elt);
+  }
+  function hideTooltip(tt) {
+    if (!tt.parentNode) return;
+    if (tt.style.opacity == null) rm(tt);
+    tt.style.opacity = 0;
+    setTimeout(function() { rm(tt); }, 600);
+  }
+
+  function showTooltipFor(e, content, node) {
+    var tooltip = showTooltip(e, content);
+    function hide() {
+      CodeMirror.off(node, "mouseout", hide);
+      if (tooltip) { hideTooltip(tooltip); tooltip = null; }
+    }
+    var poll = setInterval(function() {
+      if (tooltip) for (var n = node;; n = n.parentNode) {
+        if (n && n.nodeType == 11) n = n.host;
+        if (n == document.body) return;
+        if (!n) { hide(); break; }
+      }
+      if (!tooltip) return clearInterval(poll);
+    }, 400);
+    CodeMirror.on(node, "mouseout", hide);
+  }
+
+  function LintState(cm, options, hasGutter) {
+    this.marked = [];
+    this.options = options;
+    this.timeout = null;
+    this.hasGutter = hasGutter;
+    this.onMouseOver = function(e) { onMouseOver(cm, e); };
+  }
+
+  function parseOptions(_cm, options) {
+    if (options instanceof Function) return {getAnnotations: options};
+    if (!options || options === true) options = {};
+    return options;
+  }
+
+  function clearMarks(cm) {
+    var state = cm.state.lint;
+    if (state.hasGutter) cm.clearGutter(GUTTER_ID);
+    for (var i = 0; i < state.marked.length; ++i)
+      state.marked[i].clear();
+    state.marked.length = 0;
+  }
+
+  function makeMarker(labels, severity, multiple, tooltips) {
+    var marker = document.createElement("div"), inner = marker;
+    marker.className = "CodeMirror-lint-marker-" + severity;
+    if (multiple) {
+      inner = marker.appendChild(document.createElement("div"));
+      inner.className = "CodeMirror-lint-marker-multiple";
+    }
+
+    if (tooltips != false) CodeMirror.on(inner, "mouseover", function(e) {
+      showTooltipFor(e, labels, inner);
+    });
+
+    return marker;
+  }
+
+  function getMaxSeverity(a, b) {
+    if (a == "error") return a;
+    else return b;
+  }
+
+  function groupByLine(annotations) {
+    var lines = [];
+    for (var i = 0; i < annotations.length; ++i) {
+      var ann = annotations[i], line = ann.from.line;
+      (lines[line] || (lines[line] = [])).push(ann);
+    }
+    return lines;
+  }
+
+  function annotationTooltip(ann) {
+    var severity = ann.severity;
+    if (!severity) severity = "error";
+    var tip = document.createElement("div");
+    tip.className = "CodeMirror-lint-message-" + severity;
+    tip.appendChild(document.createTextNode(ann.message));
+    return tip;
+  }
+
+  function startLinting(cm) {
+    var state = cm.state.lint, options = state.options;
+    var passOptions = options.options || options; // Support deprecated passing of `options` property in options
+    var getAnnotations = options.getAnnotations || cm.getHelper(CodeMirror.Pos(0, 0), "lint");
+    if (!getAnnotations) return;
+    if (options.async || getAnnotations.async)
+      getAnnotations(cm.getValue(), updateLinting, passOptions, cm);
+    else
+      updateLinting(cm, getAnnotations(cm.getValue(), passOptions, cm));
+  }
+
+  function updateLinting(cm, annotationsNotSorted) {
+    clearMarks(cm);
+    var state = cm.state.lint, options = state.options;
+
+    var annotations = groupByLine(annotationsNotSorted);
+
+    for (var line = 0; line < annotations.length; ++line) {
+      var anns = annotations[line];
+      if (!anns) continue;
+
+      var maxSeverity = null;
+      var tipLabel = state.hasGutter && document.createDocumentFragment();
+
+      for (var i = 0; i < anns.length; ++i) {
+        var ann = anns[i];
+        var severity = ann.severity;
+        if (!severity) severity = "error";
+        maxSeverity = getMaxSeverity(maxSeverity, severity);
+
+        if (options.formatAnnotation) ann = options.formatAnnotation(ann);
+        if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann));
+
+        if (ann.to) state.marked.push(cm.markText(ann.from, ann.to, {
+          className: "CodeMirror-lint-mark-" + severity,
+          __annotation: ann
+        }));
+      }
+
+      if (state.hasGutter)
+        cm.setGutterMarker(line, GUTTER_ID, makeMarker(tipLabel, maxSeverity, anns.length > 1,
+                                                       state.options.tooltips));
+    }
+    if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm);
+  }
+
+  function onChange(cm) {
+    var state = cm.state.lint;
+    if (!state) return;
+    clearTimeout(state.timeout);
+    state.timeout = setTimeout(function(){startLinting(cm);}, state.options.delay || 500);
+  }
+
+  function popupSpanTooltip(ann, e) {
+    var target = e.target || e.srcElement;
+    showTooltipFor(e, annotationTooltip(ann), target);
+  }
+
+  function onMouseOver(cm, e) {
+    var target = e.target || e.srcElement;
+    if (!/\bCodeMirror-lint-mark-/.test(target.className)) return;
+    var box = target.getBoundingClientRect(), x = (box.left + box.right) / 2, y = (box.top + box.bottom) / 2;
+    var spans = cm.findMarksAt(cm.coordsChar({left: x, top: y}, "client"));
+    for (var i = 0; i < spans.length; ++i) {
+      var ann = spans[i].__annotation;
+      if (ann) return popupSpanTooltip(ann, e);
+    }
+  }
+
+  CodeMirror.defineOption("lint", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      clearMarks(cm);
+      cm.off("change", onChange);
+      CodeMirror.off(cm.getWrapperElement(), "mouseover", cm.state.lint.onMouseOver);
+      clearTimeout(cm.state.lint.timeout);
+      delete cm.state.lint;
+    }
+
+    if (val) {
+      var gutters = cm.getOption("gutters"), hasLintGutter = false;
+      for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true;
+      var state = cm.state.lint = new LintState(cm, parseOptions(cm, val), hasLintGutter);
+      cm.on("change", onChange);
+      if (state.options.tooltips != false)
+        CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver);
+
+      startLinting(cm);
+    }
+  });
+});
diff --git a/src/main/resources/codemirror/addon/lint/yaml-lint.js b/src/main/resources/codemirror/addon/lint/yaml-lint.js
new file mode 100755
index 0000000..3f77e52
--- /dev/null
+++ b/src/main/resources/codemirror/addon/lint/yaml-lint.js
@@ -0,0 +1,28 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+// Depends on js-yaml.js from https://github.com/nodeca/js-yaml
+
+// declare global: jsyaml
+
+CodeMirror.registerHelper("lint", "yaml", function(text) {
+  var found = [];
+  try { jsyaml.load(text); }
+  catch(e) {
+      var loc = e.mark;
+      found.push({ from: CodeMirror.Pos(loc.line, loc.column), to: CodeMirror.Pos(loc.line, loc.column), message: e.message });
+  }
+  return found;
+});
+
+});
diff --git a/src/main/resources/codemirror/addon/merge/merge.css b/src/main/resources/codemirror/addon/merge/merge.css
new file mode 100755
index 0000000..a6a80e4
--- /dev/null
+++ b/src/main/resources/codemirror/addon/merge/merge.css
@@ -0,0 +1,112 @@
+.CodeMirror-merge {
+  position: relative;
+  border: 1px solid #ddd;
+  white-space: pre;
+}
+
+.CodeMirror-merge, .CodeMirror-merge .CodeMirror {
+  height: 350px;
+}
+
+.CodeMirror-merge-2pane .CodeMirror-merge-pane { width: 47%; }
+.CodeMirror-merge-2pane .CodeMirror-merge-gap { width: 6%; }
+.CodeMirror-merge-3pane .CodeMirror-merge-pane { width: 31%; }
+.CodeMirror-merge-3pane .CodeMirror-merge-gap { width: 3.5%; }
+
+.CodeMirror-merge-pane {
+  display: inline-block;
+  white-space: normal;
+  vertical-align: top;
+}
+.CodeMirror-merge-pane-rightmost {
+  position: absolute;
+  right: 0px;
+  z-index: 1;
+}
+
+.CodeMirror-merge-gap {
+  z-index: 2;
+  display: inline-block;
+  height: 100%;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  overflow: hidden;
+  border-left: 1px solid #ddd;
+  border-right: 1px solid #ddd;
+  position: relative;
+  background: #f8f8f8;
+}
+
+.CodeMirror-merge-scrolllock-wrap {
+  position: absolute;
+  bottom: 0; left: 50%;
+}
+.CodeMirror-merge-scrolllock {
+  position: relative;
+  left: -50%;
+  cursor: pointer;
+  color: #555;
+  line-height: 1;
+}
+
+.CodeMirror-merge-copybuttons-left, .CodeMirror-merge-copybuttons-right {
+  position: absolute;
+  left: 0; top: 0;
+  right: 0; bottom: 0;
+  line-height: 1;
+}
+
+.CodeMirror-merge-copy {
+  position: absolute;
+  cursor: pointer;
+  color: #44c;
+}
+
+.CodeMirror-merge-copy-reverse {
+  position: absolute;
+  cursor: pointer;
+  color: #44c;
+}
+
+.CodeMirror-merge-copybuttons-left .CodeMirror-merge-copy { left: 2px; }
+.CodeMirror-merge-copybuttons-right .CodeMirror-merge-copy { right: 2px; }
+
+.CodeMirror-merge-r-inserted, .CodeMirror-merge-l-inserted {
+  background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12MwuCXy3+CWyH8GBgYGJgYkAABZbAQ9ELXurwAAAABJRU5ErkJggg==);
+  background-position: bottom left;
+  background-repeat: repeat-x;
+}
+
+.CodeMirror-merge-r-deleted, .CodeMirror-merge-l-deleted {
+  background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12M4Kyb2/6yY2H8GBgYGJgYkAABURgPz6Ks7wQAAAABJRU5ErkJggg==);
+  background-position: bottom left;
+  background-repeat: repeat-x;
+}
+
+.CodeMirror-merge-r-chunk { background: #ffffe0; }
+.CodeMirror-merge-r-chunk-start { border-top: 1px solid #ee8; }
+.CodeMirror-merge-r-chunk-end { border-bottom: 1px solid #ee8; }
+.CodeMirror-merge-r-connect { fill: #ffffe0; stroke: #ee8; stroke-width: 1px; }
+
+.CodeMirror-merge-l-chunk { background: #eef; }
+.CodeMirror-merge-l-chunk-start { border-top: 1px solid #88e; }
+.CodeMirror-merge-l-chunk-end { border-bottom: 1px solid #88e; }
+.CodeMirror-merge-l-connect { fill: #eef; stroke: #88e; stroke-width: 1px; }
+
+.CodeMirror-merge-l-chunk.CodeMirror-merge-r-chunk { background: #dfd; }
+.CodeMirror-merge-l-chunk-start.CodeMirror-merge-r-chunk-start { border-top: 1px solid #4e4; }
+.CodeMirror-merge-l-chunk-end.CodeMirror-merge-r-chunk-end { border-bottom: 1px solid #4e4; }
+
+.CodeMirror-merge-collapsed-widget:before {
+  content: "(...)";
+}
+.CodeMirror-merge-collapsed-widget {
+  cursor: pointer;
+  color: #88b;
+  background: #eef;
+  border: 1px solid #ddf;
+  font-size: 90%;
+  padding: 0 3px;
+  border-radius: 4px;
+}
+.CodeMirror-merge-collapsed-line .CodeMirror-gutter-elt { display: none; }
diff --git a/src/main/resources/codemirror/addon/merge/merge.js b/src/main/resources/codemirror/addon/merge/merge.js
new file mode 100755
index 0000000..5b04b03
--- /dev/null
+++ b/src/main/resources/codemirror/addon/merge/merge.js
@@ -0,0 +1,775 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// declare global: diff_match_patch, DIFF_INSERT, DIFF_DELETE, DIFF_EQUAL
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("diff_match_patch"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "diff_match_patch"], mod);
+  else // Plain browser env
+    mod(CodeMirror, diff_match_patch);
+})(function(CodeMirror, diff_match_patch) {
+  "use strict";
+  var Pos = CodeMirror.Pos;
+  var svgNS = "http://www.w3.org/2000/svg";
+
+  function DiffView(mv, type) {
+    this.mv = mv;
+    this.type = type;
+    this.classes = type == "left"
+      ? {chunk: "CodeMirror-merge-l-chunk",
+         start: "CodeMirror-merge-l-chunk-start",
+         end: "CodeMirror-merge-l-chunk-end",
+         insert: "CodeMirror-merge-l-inserted",
+         del: "CodeMirror-merge-l-deleted",
+         connect: "CodeMirror-merge-l-connect"}
+      : {chunk: "CodeMirror-merge-r-chunk",
+         start: "CodeMirror-merge-r-chunk-start",
+         end: "CodeMirror-merge-r-chunk-end",
+         insert: "CodeMirror-merge-r-inserted",
+         del: "CodeMirror-merge-r-deleted",
+         connect: "CodeMirror-merge-r-connect"};
+  }
+
+  DiffView.prototype = {
+    constructor: DiffView,
+    init: function(pane, orig, options) {
+      this.edit = this.mv.edit;
+      (this.edit.state.diffViews || (this.edit.state.diffViews = [])).push(this);
+      this.orig = CodeMirror(pane, copyObj({value: orig, readOnly: !this.mv.options.allowEditingOriginals}, copyObj(options)));
+      this.orig.state.diffViews = [this];
+
+      this.diff = getDiff(asString(orig), asString(options.value));
+      this.chunks = getChunks(this.diff);
+      this.diffOutOfDate = this.dealigned = false;
+
+      this.showDifferences = options.showDifferences !== false;
+      this.forceUpdate = registerUpdate(this);
+      setScrollLock(this, true, false);
+      registerScroll(this);
+    },
+    setShowDifferences: function(val) {
+      val = val !== false;
+      if (val != this.showDifferences) {
+        this.showDifferences = val;
+        this.forceUpdate("full");
+      }
+    }
+  };
+
+  function ensureDiff(dv) {
+    if (dv.diffOutOfDate) {
+      dv.diff = getDiff(dv.orig.getValue(), dv.edit.getValue());
+      dv.chunks = getChunks(dv.diff);
+      dv.diffOutOfDate = false;
+      CodeMirror.signal(dv.edit, "updateDiff", dv.diff);
+    }
+  }
+
+  var updating = false;
+  function registerUpdate(dv) {
+    var edit = {from: 0, to: 0, marked: []};
+    var orig = {from: 0, to: 0, marked: []};
+    var debounceChange, updatingFast = false;
+    function update(mode) {
+      updating = true;
+      updatingFast = false;
+      if (mode == "full") {
+        if (dv.svg) clear(dv.svg);
+        if (dv.copyButtons) clear(dv.copyButtons);
+        clearMarks(dv.edit, edit.marked, dv.classes);
+        clearMarks(dv.orig, orig.marked, dv.classes);
+        edit.from = edit.to = orig.from = orig.to = 0;
+      }
+      ensureDiff(dv);
+      if (dv.showDifferences) {
+        updateMarks(dv.edit, dv.diff, edit, DIFF_INSERT, dv.classes);
+        updateMarks(dv.orig, dv.diff, orig, DIFF_DELETE, dv.classes);
+      }
+      makeConnections(dv);
+
+      if (dv.mv.options.connect == "align")
+        alignChunks(dv);
+      updating = false;
+    }
+    function setDealign(fast) {
+      if (updating) return;
+      dv.dealigned = true;
+      set(fast);
+    }
+    function set(fast) {
+      if (updating || updatingFast) return;
+      clearTimeout(debounceChange);
+      if (fast === true) updatingFast = true;
+      debounceChange = setTimeout(update, fast === true ? 20 : 250);
+    }
+    function change(_cm, change) {
+      if (!dv.diffOutOfDate) {
+        dv.diffOutOfDate = true;
+        edit.from = edit.to = orig.from = orig.to = 0;
+      }
+      // Update faster when a line was added/removed
+      setDealign(change.text.length - 1 != change.to.line - change.from.line);
+    }
+    dv.edit.on("change", change);
+    dv.orig.on("change", change);
+    dv.edit.on("markerAdded", setDealign);
+    dv.edit.on("markerCleared", setDealign);
+    dv.orig.on("markerAdded", setDealign);
+    dv.orig.on("markerCleared", setDealign);
+    dv.edit.on("viewportChange", function() { set(false); });
+    dv.orig.on("viewportChange", function() { set(false); });
+    update();
+    return update;
+  }
+
+  function registerScroll(dv) {
+    dv.edit.on("scroll", function() {
+      syncScroll(dv, DIFF_INSERT) && makeConnections(dv);
+    });
+    dv.orig.on("scroll", function() {
+      syncScroll(dv, DIFF_DELETE) && makeConnections(dv);
+    });
+  }
+
+  function syncScroll(dv, type) {
+    // Change handler will do a refresh after a timeout when diff is out of date
+    if (dv.diffOutOfDate) return false;
+    if (!dv.lockScroll) return true;
+    var editor, other, now = +new Date;
+    if (type == DIFF_INSERT) { editor = dv.edit; other = dv.orig; }
+    else { editor = dv.orig; other = dv.edit; }
+    // Don't take action if the position of this editor was recently set
+    // (to prevent feedback loops)
+    if (editor.state.scrollSetBy == dv && (editor.state.scrollSetAt || 0) + 50 > now) return false;
+
+    var sInfo = editor.getScrollInfo();
+    if (dv.mv.options.connect == "align") {
+      targetPos = sInfo.top;
+    } else {
+      var halfScreen = .5 * sInfo.clientHeight, midY = sInfo.top + halfScreen;
+      var mid = editor.lineAtHeight(midY, "local");
+      var around = chunkBoundariesAround(dv.chunks, mid, type == DIFF_INSERT);
+      var off = getOffsets(editor, type == DIFF_INSERT ? around.edit : around.orig);
+      var offOther = getOffsets(other, type == DIFF_INSERT ? around.orig : around.edit);
+      var ratio = (midY - off.top) / (off.bot - off.top);
+      var targetPos = (offOther.top - halfScreen) + ratio * (offOther.bot - offOther.top);
+
+      var botDist, mix;
+      // Some careful tweaking to make sure no space is left out of view
+      // when scrolling to top or bottom.
+      if (targetPos > sInfo.top && (mix = sInfo.top / halfScreen) < 1) {
+        targetPos = targetPos * mix + sInfo.top * (1 - mix);
+      } else if ((botDist = sInfo.height - sInfo.clientHeight - sInfo.top) < halfScreen) {
+        var otherInfo = other.getScrollInfo();
+        var botDistOther = otherInfo.height - otherInfo.clientHeight - targetPos;
+        if (botDistOther > botDist && (mix = botDist / halfScreen) < 1)
+          targetPos = targetPos * mix + (otherInfo.height - otherInfo.clientHeight - botDist) * (1 - mix);
+      }
+    }
+
+    other.scrollTo(sInfo.left, targetPos);
+    other.state.scrollSetAt = now;
+    other.state.scrollSetBy = dv;
+    return true;
+  }
+
+  function getOffsets(editor, around) {
+    var bot = around.after;
+    if (bot == null) bot = editor.lastLine() + 1;
+    return {top: editor.heightAtLine(around.before || 0, "local"),
+            bot: editor.heightAtLine(bot, "local")};
+  }
+
+  function setScrollLock(dv, val, action) {
+    dv.lockScroll = val;
+    if (val && action != false) syncScroll(dv, DIFF_INSERT) && makeConnections(dv);
+    dv.lockButton.innerHTML = val ? "\u21db\u21da" : "\u21db&nbsp;&nbsp;\u21da";
+  }
+
+  // Updating the marks for editor content
+
+  function clearMarks(editor, arr, classes) {
+    for (var i = 0; i < arr.length; ++i) {
+      var mark = arr[i];
+      if (mark instanceof CodeMirror.TextMarker) {
+        mark.clear();
+      } else if (mark.parent) {
+        editor.removeLineClass(mark, "background", classes.chunk);
+        editor.removeLineClass(mark, "background", classes.start);
+        editor.removeLineClass(mark, "background", classes.end);
+      }
+    }
+    arr.length = 0;
+  }
+
+  // FIXME maybe add a margin around viewport to prevent too many updates
+  function updateMarks(editor, diff, state, type, classes) {
+    var vp = editor.getViewport();
+    editor.operation(function() {
+      if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) {
+        clearMarks(editor, state.marked, classes);
+        markChanges(editor, diff, type, state.marked, vp.from, vp.to, classes);
+        state.from = vp.from; state.to = vp.to;
+      } else {
+        if (vp.from < state.from) {
+          markChanges(editor, diff, type, state.marked, vp.from, state.from, classes);
+          state.from = vp.from;
+        }
+        if (vp.to > state.to) {
+          markChanges(editor, diff, type, state.marked, state.to, vp.to, classes);
+          state.to = vp.to;
+        }
+      }
+    });
+  }
+
+  function markChanges(editor, diff, type, marks, from, to, classes) {
+    var pos = Pos(0, 0);
+    var top = Pos(from, 0), bot = editor.clipPos(Pos(to - 1));
+    var cls = type == DIFF_DELETE ? classes.del : classes.insert;
+    function markChunk(start, end) {
+      var bfrom = Math.max(from, start), bto = Math.min(to, end);
+      for (var i = bfrom; i < bto; ++i) {
+        var line = editor.addLineClass(i, "background", classes.chunk);
+        if (i == start) editor.addLineClass(line, "background", classes.start);
+        if (i == end - 1) editor.addLineClass(line, "background", classes.end);
+        marks.push(line);
+      }
+      // When the chunk is empty, make sure a horizontal line shows up
+      if (start == end && bfrom == end && bto == end) {
+        if (bfrom)
+          marks.push(editor.addLineClass(bfrom - 1, "background", classes.end));
+        else
+          marks.push(editor.addLineClass(bfrom, "background", classes.start));
+      }
+    }
+
+    var chunkStart = 0;
+    for (var i = 0; i < diff.length; ++i) {
+      var part = diff[i], tp = part[0], str = part[1];
+      if (tp == DIFF_EQUAL) {
+        var cleanFrom = pos.line + (startOfLineClean(diff, i) ? 0 : 1);
+        moveOver(pos, str);
+        var cleanTo = pos.line + (endOfLineClean(diff, i) ? 1 : 0);
+        if (cleanTo > cleanFrom) {
+          if (i) markChunk(chunkStart, cleanFrom);
+          chunkStart = cleanTo;
+        }
+      } else {
+        if (tp == type) {
+          var end = moveOver(pos, str, true);
+          var a = posMax(top, pos), b = posMin(bot, end);
+          if (!posEq(a, b))
+            marks.push(editor.markText(a, b, {className: cls}));
+          pos = end;
+        }
+      }
+    }
+    if (chunkStart <= pos.line) markChunk(chunkStart, pos.line + 1);
+  }
+
+  // Updating the gap between editor and original
+
+  function makeConnections(dv) {
+    if (!dv.showDifferences) return;
+
+    if (dv.svg) {
+      clear(dv.svg);
+      var w = dv.gap.offsetWidth;
+      attrs(dv.svg, "width", w, "height", dv.gap.offsetHeight);
+    }
+    if (dv.copyButtons) clear(dv.copyButtons);
+
+    var vpEdit = dv.edit.getViewport(), vpOrig = dv.orig.getViewport();
+    var sTopEdit = dv.edit.getScrollInfo().top, sTopOrig = dv.orig.getScrollInfo().top;
+    for (var i = 0; i < dv.chunks.length; i++) {
+      var ch = dv.chunks[i];
+      if (ch.editFrom <= vpEdit.to && ch.editTo >= vpEdit.from &&
+          ch.origFrom <= vpOrig.to && ch.origTo >= vpOrig.from)
+        drawConnectorsForChunk(dv, ch, sTopOrig, sTopEdit, w);
+    }
+  }
+
+  function getMatchingOrigLine(editLine, chunks) {
+    var editStart = 0, origStart = 0;
+    for (var i = 0; i < chunks.length; i++) {
+      var chunk = chunks[i];
+      if (chunk.editTo > editLine && chunk.editFrom <= editLine) return null;
+      if (chunk.editFrom > editLine) break;
+      editStart = chunk.editTo;
+      origStart = chunk.origTo;
+    }
+    return origStart + (editLine - editStart);
+  }
+
+  function findAlignedLines(dv, other) {
+    var linesToAlign = [];
+    for (var i = 0; i < dv.chunks.length; i++) {
+      var chunk = dv.chunks[i];
+      linesToAlign.push([chunk.origTo, chunk.editTo, other ? getMatchingOrigLine(chunk.editTo, other.chunks) : null]);
+    }
+    if (other) {
+      for (var i = 0; i < other.chunks.length; i++) {
+        var chunk = other.chunks[i];
+        for (var j = 0; j < linesToAlign.length; j++) {
+          var align = linesToAlign[j];
+          if (align[1] == chunk.editTo) {
+            j = -1;
+            break;
+          } else if (align[1] > chunk.editTo) {
+            break;
+          }
+        }
+        if (j > -1)
+          linesToAlign.splice(j - 1, 0, [getMatchingOrigLine(chunk.editTo, dv.chunks), chunk.editTo, chunk.origTo]);
+      }
+    }
+    return linesToAlign;
+  }
+
+  function alignChunks(dv, force) {
+    if (!dv.dealigned && !force) return;
+    if (!dv.orig.curOp) return dv.orig.operation(function() {
+      alignChunks(dv, force);
+    });
+
+    dv.dealigned = false;
+    var other = dv.mv.left == dv ? dv.mv.right : dv.mv.left;
+    if (other) {
+      ensureDiff(other);
+      other.dealigned = false;
+    }
+    var linesToAlign = findAlignedLines(dv, other);
+
+    // Clear old aligners
+    var aligners = dv.mv.aligners;
+    for (var i = 0; i < aligners.length; i++)
+      aligners[i].clear();
+    aligners.length = 0;
+
+    var cm = [dv.orig, dv.edit], scroll = [];
+    if (other) cm.push(other.orig);
+    for (var i = 0; i < cm.length; i++)
+      scroll.push(cm[i].getScrollInfo().top);
+
+    for (var ln = 0; ln < linesToAlign.length; ln++)
+      alignLines(cm, linesToAlign[ln], aligners);
+
+    for (var i = 0; i < cm.length; i++)
+      cm[i].scrollTo(null, scroll[i]);
+  }
+
+  function alignLines(cm, lines, aligners) {
+    var maxOffset = 0, offset = [];
+    for (var i = 0; i < cm.length; i++) if (lines[i] != null) {
+      var off = cm[i].heightAtLine(lines[i], "local");
+      offset[i] = off;
+      maxOffset = Math.max(maxOffset, off);
+    }
+    for (var i = 0; i < cm.length; i++) if (lines[i] != null) {
+      var diff = maxOffset - offset[i];
+      if (diff > 1)
+        aligners.push(padAbove(cm[i], lines[i], diff));
+    }
+  }
+
+  function padAbove(cm, line, size) {
+    var above = true;
+    if (line > cm.lastLine()) {
+      line--;
+      above = false;
+    }
+    var elt = document.createElement("div");
+    elt.className = "CodeMirror-merge-spacer";
+    elt.style.height = size + "px"; elt.style.minWidth = "1px";
+    return cm.addLineWidget(line, elt, {height: size, above: above});
+  }
+
+  function drawConnectorsForChunk(dv, chunk, sTopOrig, sTopEdit, w) {
+    var flip = dv.type == "left";
+    var top = dv.orig.heightAtLine(chunk.origFrom, "local") - sTopOrig;
+    if (dv.svg) {
+      var topLpx = top;
+      var topRpx = dv.edit.heightAtLine(chunk.editFrom, "local") - sTopEdit;
+      if (flip) { var tmp = topLpx; topLpx = topRpx; topRpx = tmp; }
+      var botLpx = dv.orig.heightAtLine(chunk.origTo, "local") - sTopOrig;
+      var botRpx = dv.edit.heightAtLine(chunk.editTo, "local") - sTopEdit;
+      if (flip) { var tmp = botLpx; botLpx = botRpx; botRpx = tmp; }
+      var curveTop = " C " + w/2 + " " + topRpx + " " + w/2 + " " + topLpx + " " + (w + 2) + " " + topLpx;
+      var curveBot = " C " + w/2 + " " + botLpx + " " + w/2 + " " + botRpx + " -1 " + botRpx;
+      attrs(dv.svg.appendChild(document.createElementNS(svgNS, "path")),
+            "d", "M -1 " + topRpx + curveTop + " L " + (w + 2) + " " + botLpx + curveBot + " z",
+            "class", dv.classes.connect);
+    }
+    if (dv.copyButtons) {
+      var copy = dv.copyButtons.appendChild(elt("div", dv.type == "left" ? "\u21dd" : "\u21dc",
+                                                "CodeMirror-merge-copy"));
+      var editOriginals = dv.mv.options.allowEditingOriginals;
+      copy.title = editOriginals ? "Push to left" : "Revert chunk";
+      copy.chunk = chunk;
+      copy.style.top = top + "px";
+
+      if (editOriginals) {
+        var topReverse = dv.orig.heightAtLine(chunk.editFrom, "local") - sTopEdit;
+        var copyReverse = dv.copyButtons.appendChild(elt("div", dv.type == "right" ? "\u21dd" : "\u21dc",
+                                                         "CodeMirror-merge-copy-reverse"));
+        copyReverse.title = "Push to right";
+        copyReverse.chunk = {editFrom: chunk.origFrom, editTo: chunk.origTo,
+                             origFrom: chunk.editFrom, origTo: chunk.editTo};
+        copyReverse.style.top = topReverse + "px";
+        dv.type == "right" ? copyReverse.style.left = "2px" : copyReverse.style.right = "2px";
+      }
+    }
+  }
+
+  function copyChunk(dv, to, from, chunk) {
+    if (dv.diffOutOfDate) return;
+    to.replaceRange(from.getRange(Pos(chunk.origFrom, 0), Pos(chunk.origTo, 0)),
+                         Pos(chunk.editFrom, 0), Pos(chunk.editTo, 0));
+  }
+
+  // Merge view, containing 0, 1, or 2 diff views.
+
+  var MergeView = CodeMirror.MergeView = function(node, options) {
+    if (!(this instanceof MergeView)) return new MergeView(node, options);
+
+    this.options = options;
+    var origLeft = options.origLeft, origRight = options.origRight == null ? options.orig : options.origRight;
+
+    var hasLeft = origLeft != null, hasRight = origRight != null;
+    var panes = 1 + (hasLeft ? 1 : 0) + (hasRight ? 1 : 0);
+    var wrap = [], left = this.left = null, right = this.right = null;
+    var self = this;
+
+    if (hasLeft) {
+      left = this.left = new DiffView(this, "left");
+      var leftPane = elt("div", null, "CodeMirror-merge-pane");
+      wrap.push(leftPane);
+      wrap.push(buildGap(left));
+    }
+
+    var editPane = elt("div", null, "CodeMirror-merge-pane");
+    wrap.push(editPane);
+
+    if (hasRight) {
+      right = this.right = new DiffView(this, "right");
+      wrap.push(buildGap(right));
+      var rightPane = elt("div", null, "CodeMirror-merge-pane");
+      wrap.push(rightPane);
+    }
+
+    (hasRight ? rightPane : editPane).className += " CodeMirror-merge-pane-rightmost";
+
+    wrap.push(elt("div", null, null, "height: 0; clear: both;"));
+
+    var wrapElt = this.wrap = node.appendChild(elt("div", wrap, "CodeMirror-merge CodeMirror-merge-" + panes + "pane"));
+    this.edit = CodeMirror(editPane, copyObj(options));
+
+    if (left) left.init(leftPane, origLeft, options);
+    if (right) right.init(rightPane, origRight, options);
+
+    if (options.collapseIdentical) {
+      updating = true;
+      this.editor().operation(function() {
+        collapseIdenticalStretches(self, options.collapseIdentical);
+      });
+      updating = false;
+    }
+    if (options.connect == "align") {
+      this.aligners = [];
+      alignChunks(this.left || this.right, true);
+    }
+
+    var onResize = function() {
+      if (left) makeConnections(left);
+      if (right) makeConnections(right);
+    };
+    CodeMirror.on(window, "resize", onResize);
+    var resizeInterval = setInterval(function() {
+      for (var p = wrapElt.parentNode; p && p != document.body; p = p.parentNode) {}
+      if (!p) { clearInterval(resizeInterval); CodeMirror.off(window, "resize", onResize); }
+    }, 5000);
+  };
+
+  function buildGap(dv) {
+    var lock = dv.lockButton = elt("div", null, "CodeMirror-merge-scrolllock");
+    lock.title = "Toggle locked scrolling";
+    var lockWrap = elt("div", [lock], "CodeMirror-merge-scrolllock-wrap");
+    CodeMirror.on(lock, "click", function() { setScrollLock(dv, !dv.lockScroll); });
+    var gapElts = [lockWrap];
+    if (dv.mv.options.revertButtons !== false) {
+      dv.copyButtons = elt("div", null, "CodeMirror-merge-copybuttons-" + dv.type);
+      CodeMirror.on(dv.copyButtons, "click", function(e) {
+        var node = e.target || e.srcElement;
+        if (!node.chunk) return;
+        if (node.className == "CodeMirror-merge-copy-reverse") {
+          copyChunk(dv, dv.orig, dv.edit, node.chunk);
+          return;
+        }
+        copyChunk(dv, dv.edit, dv.orig, node.chunk);
+      });
+      gapElts.unshift(dv.copyButtons);
+    }
+    if (dv.mv.options.connect != "align") {
+      var svg = document.createElementNS && document.createElementNS(svgNS, "svg");
+      if (svg && !svg.createSVGRect) svg = null;
+      dv.svg = svg;
+      if (svg) gapElts.push(svg);
+    }
+
+    return dv.gap = elt("div", gapElts, "CodeMirror-merge-gap");
+  }
+
+  MergeView.prototype = {
+    constuctor: MergeView,
+    editor: function() { return this.edit; },
+    rightOriginal: function() { return this.right && this.right.orig; },
+    leftOriginal: function() { return this.left && this.left.orig; },
+    setShowDifferences: function(val) {
+      if (this.right) this.right.setShowDifferences(val);
+      if (this.left) this.left.setShowDifferences(val);
+    },
+    rightChunks: function() {
+      if (this.right) { ensureDiff(this.right); return this.right.chunks; }
+    },
+    leftChunks: function() {
+      if (this.left) { ensureDiff(this.left); return this.left.chunks; }
+    }
+  };
+
+  function asString(obj) {
+    if (typeof obj == "string") return obj;
+    else return obj.getValue();
+  }
+
+  // Operations on diffs
+
+  var dmp = new diff_match_patch();
+  function getDiff(a, b) {
+    var diff = dmp.diff_main(a, b);
+    dmp.diff_cleanupSemantic(diff);
+    // The library sometimes leaves in empty parts, which confuse the algorithm
+    for (var i = 0; i < diff.length; ++i) {
+      var part = diff[i];
+      if (!part[1]) {
+        diff.splice(i--, 1);
+      } else if (i && diff[i - 1][0] == part[0]) {
+        diff.splice(i--, 1);
+        diff[i][1] += part[1];
+      }
+    }
+    return diff;
+  }
+
+  function getChunks(diff) {
+    var chunks = [];
+    var startEdit = 0, startOrig = 0;
+    var edit = Pos(0, 0), orig = Pos(0, 0);
+    for (var i = 0; i < diff.length; ++i) {
+      var part = diff[i], tp = part[0];
+      if (tp == DIFF_EQUAL) {
+        var startOff = startOfLineClean(diff, i) ? 0 : 1;
+        var cleanFromEdit = edit.line + startOff, cleanFromOrig = orig.line + startOff;
+        moveOver(edit, part[1], null, orig);
+        var endOff = endOfLineClean(diff, i) ? 1 : 0;
+        var cleanToEdit = edit.line + endOff, cleanToOrig = orig.line + endOff;
+        if (cleanToEdit > cleanFromEdit) {
+          if (i) chunks.push({origFrom: startOrig, origTo: cleanFromOrig,
+                              editFrom: startEdit, editTo: cleanFromEdit});
+          startEdit = cleanToEdit; startOrig = cleanToOrig;
+        }
+      } else {
+        moveOver(tp == DIFF_INSERT ? edit : orig, part[1]);
+      }
+    }
+    if (startEdit <= edit.line || startOrig <= orig.line)
+      chunks.push({origFrom: startOrig, origTo: orig.line + 1,
+                   editFrom: startEdit, editTo: edit.line + 1});
+    return chunks;
+  }
+
+  function endOfLineClean(diff, i) {
+    if (i == diff.length - 1) return true;
+    var next = diff[i + 1][1];
+    if (next.length == 1 || next.charCodeAt(0) != 10) return false;
+    if (i == diff.length - 2) return true;
+    next = diff[i + 2][1];
+    return next.length > 1 && next.charCodeAt(0) == 10;
+  }
+
+  function startOfLineClean(diff, i) {
+    if (i == 0) return true;
+    var last = diff[i - 1][1];
+    if (last.charCodeAt(last.length - 1) != 10) return false;
+    if (i == 1) return true;
+    last = diff[i - 2][1];
+    return last.charCodeAt(last.length - 1) == 10;
+  }
+
+  function chunkBoundariesAround(chunks, n, nInEdit) {
+    var beforeE, afterE, beforeO, afterO;
+    for (var i = 0; i < chunks.length; i++) {
+      var chunk = chunks[i];
+      var fromLocal = nInEdit ? chunk.editFrom : chunk.origFrom;
+      var toLocal = nInEdit ? chunk.editTo : chunk.origTo;
+      if (afterE == null) {
+        if (fromLocal > n) { afterE = chunk.editFrom; afterO = chunk.origFrom; }
+        else if (toLocal > n) { afterE = chunk.editTo; afterO = chunk.origTo; }
+      }
+      if (toLocal <= n) { beforeE = chunk.editTo; beforeO = chunk.origTo; }
+      else if (fromLocal <= n) { beforeE = chunk.editFrom; beforeO = chunk.origFrom; }
+    }
+    return {edit: {before: beforeE, after: afterE}, orig: {before: beforeO, after: afterO}};
+  }
+
+  function collapseSingle(cm, from, to) {
+    cm.addLineClass(from, "wrap", "CodeMirror-merge-collapsed-line");
+    var widget = document.createElement("span");
+    widget.className = "CodeMirror-merge-collapsed-widget";
+    widget.title = "Identical text collapsed. Click to expand.";
+    var mark = cm.markText(Pos(from, 0), Pos(to - 1), {
+      inclusiveLeft: true,
+      inclusiveRight: true,
+      replacedWith: widget,
+      clearOnEnter: true
+    });
+    function clear() {
+      mark.clear();
+      cm.removeLineClass(from, "wrap", "CodeMirror-merge-collapsed-line");
+    }
+    widget.addEventListener("click", clear);
+    return {mark: mark, clear: clear};
+  }
+
+  function collapseStretch(size, editors) {
+    var marks = [];
+    function clear() {
+      for (var i = 0; i < marks.length; i++) marks[i].clear();
+    }
+    for (var i = 0; i < editors.length; i++) {
+      var editor = editors[i];
+      var mark = collapseSingle(editor.cm, editor.line, editor.line + size);
+      marks.push(mark);
+      mark.mark.on("clear", clear);
+    }
+    return marks[0].mark;
+  }
+
+  function unclearNearChunks(dv, margin, off, clear) {
+    for (var i = 0; i < dv.chunks.length; i++) {
+      var chunk = dv.chunks[i];
+      for (var l = chunk.editFrom - margin; l < chunk.editTo + margin; l++) {
+        var pos = l + off;
+        if (pos >= 0 && pos < clear.length) clear[pos] = false;
+      }
+    }
+  }
+
+  function collapseIdenticalStretches(mv, margin) {
+    if (typeof margin != "number") margin = 2;
+    var clear = [], edit = mv.editor(), off = edit.firstLine();
+    for (var l = off, e = edit.lastLine(); l <= e; l++) clear.push(true);
+    if (mv.left) unclearNearChunks(mv.left, margin, off, clear);
+    if (mv.right) unclearNearChunks(mv.right, margin, off, clear);
+
+    for (var i = 0; i < clear.length; i++) {
+      if (clear[i]) {
+        var line = i + off;
+        for (var size = 1; i < clear.length - 1 && clear[i + 1]; i++, size++) {}
+        if (size > margin) {
+          var editors = [{line: line, cm: edit}];
+          if (mv.left) editors.push({line: getMatchingOrigLine(line, mv.left.chunks), cm: mv.left.orig});
+          if (mv.right) editors.push({line: getMatchingOrigLine(line, mv.right.chunks), cm: mv.right.orig});
+          var mark = collapseStretch(size, editors);
+          if (mv.options.onCollapse) mv.options.onCollapse(mv, line, size, mark);
+        }
+      }
+    }
+  }
+
+  // General utilities
+
+  function elt(tag, content, className, style) {
+    var e = document.createElement(tag);
+    if (className) e.className = className;
+    if (style) e.style.cssText = style;
+    if (typeof content == "string") e.appendChild(document.createTextNode(content));
+    else if (content) for (var i = 0; i < content.length; ++i) e.appendChild(content[i]);
+    return e;
+  }
+
+  function clear(node) {
+    for (var count = node.childNodes.length; count > 0; --count)
+      node.removeChild(node.firstChild);
+  }
+
+  function attrs(elt) {
+    for (var i = 1; i < arguments.length; i += 2)
+      elt.setAttribute(arguments[i], arguments[i+1]);
+  }
+
+  function copyObj(obj, target) {
+    if (!target) target = {};
+    for (var prop in obj) if (obj.hasOwnProperty(prop)) target[prop] = obj[prop];
+    return target;
+  }
+
+  function moveOver(pos, str, copy, other) {
+    var out = copy ? Pos(pos.line, pos.ch) : pos, at = 0;
+    for (;;) {
+      var nl = str.indexOf("\n", at);
+      if (nl == -1) break;
+      ++out.line;
+      if (other) ++other.line;
+      at = nl + 1;
+    }
+    out.ch = (at ? 0 : out.ch) + (str.length - at);
+    if (other) other.ch = (at ? 0 : other.ch) + (str.length - at);
+    return out;
+  }
+
+  function posMin(a, b) { return (a.line - b.line || a.ch - b.ch) < 0 ? a : b; }
+  function posMax(a, b) { return (a.line - b.line || a.ch - b.ch) > 0 ? a : b; }
+  function posEq(a, b) { return a.line == b.line && a.ch == b.ch; }
+
+  function findPrevDiff(chunks, start, isOrig) {
+    for (var i = chunks.length - 1; i >= 0; i--) {
+      var chunk = chunks[i];
+      var to = (isOrig ? chunk.origTo : chunk.editTo) - 1;
+      if (to < start) return to;
+    }
+  }
+
+  function findNextDiff(chunks, start, isOrig) {
+    for (var i = 0; i < chunks.length; i++) {
+      var chunk = chunks[i];
+      var from = (isOrig ? chunk.origFrom : chunk.editFrom);
+      if (from > start) return from;
+    }
+  }
+
+  function goNearbyDiff(cm, dir) {
+    var found = null, views = cm.state.diffViews, line = cm.getCursor().line;
+    if (views) for (var i = 0; i < views.length; i++) {
+      var dv = views[i], isOrig = cm == dv.orig;
+      ensureDiff(dv);
+      var pos = dir < 0 ? findPrevDiff(dv.chunks, line, isOrig) : findNextDiff(dv.chunks, line, isOrig);
+      if (pos != null && (found == null || (dir < 0 ? pos > found : pos < found)))
+        found = pos;
+    }
+    if (found != null)
+      cm.setCursor(found, 0);
+    else
+      return CodeMirror.Pass;
+  }
+
+  CodeMirror.commands.goNextDiff = function(cm) {
+    return goNearbyDiff(cm, 1);
+  };
+  CodeMirror.commands.goPrevDiff = function(cm) {
+    return goNearbyDiff(cm, -1);
+  };
+});
diff --git a/src/main/resources/codemirror/addon/mode/loadmode.js b/src/main/resources/codemirror/addon/mode/loadmode.js
new file mode 100755
index 0000000..10117ec
--- /dev/null
+++ b/src/main/resources/codemirror/addon/mode/loadmode.js
@@ -0,0 +1,64 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), "cjs");
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], function(CM) { mod(CM, "amd"); });
+  else // Plain browser env
+    mod(CodeMirror, "plain");
+})(function(CodeMirror, env) {
+  if (!CodeMirror.modeURL) CodeMirror.modeURL = "../mode/%N/%N.js";
+
+  var loading = {};
+  function splitCallback(cont, n) {
+    var countDown = n;
+    return function() { if (--countDown == 0) cont(); };
+  }
+  function ensureDeps(mode, cont) {
+    var deps = CodeMirror.modes[mode].dependencies;
+    if (!deps) return cont();
+    var missing = [];
+    for (var i = 0; i < deps.length; ++i) {
+      if (!CodeMirror.modes.hasOwnProperty(deps[i]))
+        missing.push(deps[i]);
+    }
+    if (!missing.length) return cont();
+    var split = splitCallback(cont, missing.length);
+    for (var i = 0; i < missing.length; ++i)
+      CodeMirror.requireMode(missing[i], split);
+  }
+
+  CodeMirror.requireMode = function(mode, cont) {
+    if (typeof mode != "string") mode = mode.name;
+    if (CodeMirror.modes.hasOwnProperty(mode)) return ensureDeps(mode, cont);
+    if (loading.hasOwnProperty(mode)) return loading[mode].push(cont);
+
+    var file = CodeMirror.modeURL.replace(/%N/g, mode);
+    if (env == "plain") {
+      var script = document.createElement("script");
+      script.src = file;
+      var others = document.getElementsByTagName("script")[0];
+      var list = loading[mode] = [cont];
+      CodeMirror.on(script, "load", function() {
+        ensureDeps(mode, function() {
+          for (var i = 0; i < list.length; ++i) list[i]();
+        });
+      });
+      others.parentNode.insertBefore(script, others);
+    } else if (env == "cjs") {
+      require(file);
+      cont();
+    } else if (env == "amd") {
+      requirejs([file], cont);
+    }
+  };
+
+  CodeMirror.autoLoadMode = function(instance, mode) {
+    if (!CodeMirror.modes.hasOwnProperty(mode))
+      CodeMirror.requireMode(mode, function() {
+        instance.setOption("mode", instance.getOption("mode"));
+      });
+  };
+});
diff --git a/src/main/resources/codemirror/addon/mode/multiplex.js b/src/main/resources/codemirror/addon/mode/multiplex.js
new file mode 100755
index 0000000..fe48c7f
--- /dev/null
+++ b/src/main/resources/codemirror/addon/mode/multiplex.js
@@ -0,0 +1,123 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.multiplexingMode = function(outer /*, others */) {
+  // Others should be {open, close, mode [, delimStyle] [, innerStyle]} objects
+  var others = Array.prototype.slice.call(arguments, 1);
+
+  function indexOf(string, pattern, from, returnEnd) {
+    if (typeof pattern == "string") {
+      var found = string.indexOf(pattern, from);
+      return returnEnd && found > -1 ? found + pattern.length : found;
+    }
+    var m = pattern.exec(from ? string.slice(from) : string);
+    return m ? m.index + from + (returnEnd ? m[0].length : 0) : -1;
+  }
+
+  return {
+    startState: function() {
+      return {
+        outer: CodeMirror.startState(outer),
+        innerActive: null,
+        inner: null
+      };
+    },
+
+    copyState: function(state) {
+      return {
+        outer: CodeMirror.copyState(outer, state.outer),
+        innerActive: state.innerActive,
+        inner: state.innerActive && CodeMirror.copyState(state.innerActive.mode, state.inner)
+      };
+    },
+
+    token: function(stream, state) {
+      if (!state.innerActive) {
+        var cutOff = Infinity, oldContent = stream.string;
+        for (var i = 0; i < others.length; ++i) {
+          var other = others[i];
+          var found = indexOf(oldContent, other.open, stream.pos);
+          if (found == stream.pos) {
+            if (!other.parseDelimiters) stream.match(other.open);
+            state.innerActive = other;
+            state.inner = CodeMirror.startState(other.mode, outer.indent ? outer.indent(state.outer, "") : 0);
+            return other.delimStyle;
+          } else if (found != -1 && found < cutOff) {
+            cutOff = found;
+          }
+        }
+        if (cutOff != Infinity) stream.string = oldContent.slice(0, cutOff);
+        var outerToken = outer.token(stream, state.outer);
+        if (cutOff != Infinity) stream.string = oldContent;
+        return outerToken;
+      } else {
+        var curInner = state.innerActive, oldContent = stream.string;
+        if (!curInner.close && stream.sol()) {
+          state.innerActive = state.inner = null;
+          return this.token(stream, state);
+        }
+        var found = curInner.close ? indexOf(oldContent, curInner.close, stream.pos, curInner.parseDelimiters) : -1;
+        if (found == stream.pos && !curInner.parseDelimiters) {
+          stream.match(curInner.close);
+          state.innerActive = state.inner = null;
+          return curInner.delimStyle;
+        }
+        if (found > -1) stream.string = oldContent.slice(0, found);
+        var innerToken = curInner.mode.token(stream, state.inner);
+        if (found > -1) stream.string = oldContent;
+
+        if (found == stream.pos && curInner.parseDelimiters)
+          state.innerActive = state.inner = null;
+
+        if (curInner.innerStyle) {
+          if (innerToken) innerToken = innerToken + ' ' + curInner.innerStyle;
+          else innerToken = curInner.innerStyle;
+        }
+
+        return innerToken;
+      }
+    },
+
+    indent: function(state, textAfter) {
+      var mode = state.innerActive ? state.innerActive.mode : outer;
+      if (!mode.indent) return CodeMirror.Pass;
+      return mode.indent(state.innerActive ? state.inner : state.outer, textAfter);
+    },
+
+    blankLine: function(state) {
+      var mode = state.innerActive ? state.innerActive.mode : outer;
+      if (mode.blankLine) {
+        mode.blankLine(state.innerActive ? state.inner : state.outer);
+      }
+      if (!state.innerActive) {
+        for (var i = 0; i < others.length; ++i) {
+          var other = others[i];
+          if (other.open === "\n") {
+            state.innerActive = other;
+            state.inner = CodeMirror.startState(other.mode, mode.indent ? mode.indent(state.outer, "") : 0);
+          }
+        }
+      } else if (state.innerActive.close === "\n") {
+        state.innerActive = state.inner = null;
+      }
+    },
+
+    electricChars: outer.electricChars,
+
+    innerMode: function(state) {
+      return state.inner ? {state: state.inner, mode: state.innerActive.mode} : {state: state.outer, mode: outer};
+    }
+  };
+};
+
+});
diff --git a/src/main/resources/codemirror/addon/mode/multiplex_test.js b/src/main/resources/codemirror/addon/mode/multiplex_test.js
new file mode 100755
index 0000000..d339434
--- /dev/null
+++ b/src/main/resources/codemirror/addon/mode/multiplex_test.js
@@ -0,0 +1,33 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function() {
+  CodeMirror.defineMode("markdown_with_stex", function(){
+    var inner = CodeMirror.getMode({}, "stex");
+    var outer = CodeMirror.getMode({}, "markdown");
+
+    var innerOptions = {
+      open: '$',
+      close: '$',
+      mode: inner,
+      delimStyle: 'delim',
+      innerStyle: 'inner'
+    };
+
+    return CodeMirror.multiplexingMode(outer, innerOptions);
+  });
+
+  var mode = CodeMirror.getMode({}, "markdown_with_stex");
+
+  function MT(name) {
+    test.mode(
+      name,
+      mode,
+      Array.prototype.slice.call(arguments, 1),
+      'multiplexing');
+  }
+
+  MT(
+    "stexInsideMarkdown",
+    "[strong **Equation:**] [delim $][inner&tag \\pi][delim $]");
+})();
diff --git a/src/main/resources/codemirror/addon/mode/overlay.js b/src/main/resources/codemirror/addon/mode/overlay.js
new file mode 100755
index 0000000..e1b9ed3
--- /dev/null
+++ b/src/main/resources/codemirror/addon/mode/overlay.js
@@ -0,0 +1,85 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Utility function that allows modes to be combined. The mode given
+// as the base argument takes care of most of the normal mode
+// functionality, but a second (typically simple) mode is used, which
+// can override the style of text. Both modes get to parse all of the
+// text, but when both assign a non-null style to a piece of code, the
+// overlay wins, unless the combine argument was true and not overridden,
+// or state.overlay.combineTokens was true, in which case the styles are
+// combined.
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.overlayMode = function(base, overlay, combine) {
+  return {
+    startState: function() {
+      return {
+        base: CodeMirror.startState(base),
+        overlay: CodeMirror.startState(overlay),
+        basePos: 0, baseCur: null,
+        overlayPos: 0, overlayCur: null,
+        streamSeen: null
+      };
+    },
+    copyState: function(state) {
+      return {
+        base: CodeMirror.copyState(base, state.base),
+        overlay: CodeMirror.copyState(overlay, state.overlay),
+        basePos: state.basePos, baseCur: null,
+        overlayPos: state.overlayPos, overlayCur: null
+      };
+    },
+
+    token: function(stream, state) {
+      if (stream != state.streamSeen ||
+          Math.min(state.basePos, state.overlayPos) < stream.start) {
+        state.streamSeen = stream;
+        state.basePos = state.overlayPos = stream.start;
+      }
+
+      if (stream.start == state.basePos) {
+        state.baseCur = base.token(stream, state.base);
+        state.basePos = stream.pos;
+      }
+      if (stream.start == state.overlayPos) {
+        stream.pos = stream.start;
+        state.overlayCur = overlay.token(stream, state.overlay);
+        state.overlayPos = stream.pos;
+      }
+      stream.pos = Math.min(state.basePos, state.overlayPos);
+
+      // state.overlay.combineTokens always takes precedence over combine,
+      // unless set to null
+      if (state.overlayCur == null) return state.baseCur;
+      else if (state.baseCur != null &&
+               state.overlay.combineTokens ||
+               combine && state.overlay.combineTokens == null)
+        return state.baseCur + " " + state.overlayCur;
+      else return state.overlayCur;
+    },
+
+    indent: base.indent && function(state, textAfter) {
+      return base.indent(state.base, textAfter);
+    },
+    electricChars: base.electricChars,
+
+    innerMode: function(state) { return {state: state.base, mode: base}; },
+
+    blankLine: function(state) {
+      if (base.blankLine) base.blankLine(state.base);
+      if (overlay.blankLine) overlay.blankLine(state.overlay);
+    }
+  };
+};
+
+});
diff --git a/src/main/resources/codemirror/addon/mode/simple.js b/src/main/resources/codemirror/addon/mode/simple.js
new file mode 100755
index 0000000..795328b
--- /dev/null
+++ b/src/main/resources/codemirror/addon/mode/simple.js
@@ -0,0 +1,213 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineSimpleMode = function(name, states) {
+    CodeMirror.defineMode(name, function(config) {
+      return CodeMirror.simpleMode(config, states);
+    });
+  };
+
+  CodeMirror.simpleMode = function(config, states) {
+    ensureState(states, "start");
+    var states_ = {}, meta = states.meta || {}, hasIndentation = false;
+    for (var state in states) if (state != meta && states.hasOwnProperty(state)) {
+      var list = states_[state] = [], orig = states[state];
+      for (var i = 0; i < orig.length; i++) {
+        var data = orig[i];
+        list.push(new Rule(data, states));
+        if (data.indent || data.dedent) hasIndentation = true;
+      }
+    }
+    var mode = {
+      startState: function() {
+        return {state: "start", pending: null,
+                local: null, localState: null,
+                indent: hasIndentation ? [] : null};
+      },
+      copyState: function(state) {
+        var s = {state: state.state, pending: state.pending,
+                 local: state.local, localState: null,
+                 indent: state.indent && state.indent.slice(0)};
+        if (state.localState)
+          s.localState = CodeMirror.copyState(state.local.mode, state.localState);
+        if (state.stack)
+          s.stack = state.stack.slice(0);
+        for (var pers = state.persistentStates; pers; pers = pers.next)
+          s.persistentStates = {mode: pers.mode,
+                                spec: pers.spec,
+                                state: pers.state == state.localState ? s.localState : CodeMirror.copyState(pers.mode, pers.state),
+                                next: s.persistentStates};
+        return s;
+      },
+      token: tokenFunction(states_, config),
+      innerMode: function(state) { return state.local && {mode: state.local.mode, state: state.localState}; },
+      indent: indentFunction(states_, meta)
+    };
+    if (meta) for (var prop in meta) if (meta.hasOwnProperty(prop))
+      mode[prop] = meta[prop];
+    return mode;
+  };
+
+  function ensureState(states, name) {
+    if (!states.hasOwnProperty(name))
+      throw new Error("Undefined state " + name + "in simple mode");
+  }
+
+  function toRegex(val, caret) {
+    if (!val) return /(?:)/;
+    var flags = "";
+    if (val instanceof RegExp) {
+      if (val.ignoreCase) flags = "i";
+      val = val.source;
+    } else {
+      val = String(val);
+    }
+    return new RegExp((caret === false ? "" : "^") + "(?:" + val + ")", flags);
+  }
+
+  function asToken(val) {
+    if (!val) return null;
+    if (typeof val == "string") return val.replace(/\./g, " ");
+    var result = [];
+    for (var i = 0; i < val.length; i++)
+      result.push(val[i] && val[i].replace(/\./g, " "));
+    return result;
+  }
+
+  function Rule(data, states) {
+    if (data.next || data.push) ensureState(states, data.next || data.push);
+    this.regex = toRegex(data.regex);
+    this.token = asToken(data.token);
+    this.data = data;
+  }
+
+  function tokenFunction(states, config) {
+    return function(stream, state) {
+      if (state.pending) {
+        var pend = state.pending.shift();
+        if (state.pending.length == 0) state.pending = null;
+        stream.pos += pend.text.length;
+        return pend.token;
+      }
+
+      if (state.local) {
+        if (state.local.end && stream.match(state.local.end)) {
+          var tok = state.local.endToken || null;
+          state.local = state.localState = null;
+          return tok;
+        } else {
+          var tok = state.local.mode.token(stream, state.localState), m;
+          if (state.local.endScan && (m = state.local.endScan.exec(stream.current())))
+            stream.pos = stream.start + m.index;
+          return tok;
+        }
+      }
+
+      var curState = states[state.state];
+      for (var i = 0; i < curState.length; i++) {
+        var rule = curState[i];
+        var matches = (!rule.data.sol || stream.sol()) && stream.match(rule.regex);
+        if (matches) {
+          if (rule.data.next) {
+            state.state = rule.data.next;
+          } else if (rule.data.push) {
+            (state.stack || (state.stack = [])).push(state.state);
+            state.state = rule.data.push;
+          } else if (rule.data.pop && state.stack && state.stack.length) {
+            state.state = state.stack.pop();
+          }
+
+          if (rule.data.mode)
+            enterLocalMode(config, state, rule.data.mode, rule.token);
+          if (rule.data.indent)
+            state.indent.push(stream.indentation() + config.indentUnit);
+          if (rule.data.dedent)
+            state.indent.pop();
+          if (matches.length > 2) {
+            state.pending = [];
+            for (var j = 2; j < matches.length; j++)
+              if (matches[j])
+                state.pending.push({text: matches[j], token: rule.token[j - 1]});
+            stream.backUp(matches[0].length - (matches[1] ? matches[1].length : 0));
+            return rule.token[0];
+          } else if (rule.token && rule.token.join) {
+            return rule.token[0];
+          } else {
+            return rule.token;
+          }
+        }
+      }
+      stream.next();
+      return null;
+    };
+  }
+
+  function cmp(a, b) {
+    if (a === b) return true;
+    if (!a || typeof a != "object" || !b || typeof b != "object") return false;
+    var props = 0;
+    for (var prop in a) if (a.hasOwnProperty(prop)) {
+      if (!b.hasOwnProperty(prop) || !cmp(a[prop], b[prop])) return false;
+      props++;
+    }
+    for (var prop in b) if (b.hasOwnProperty(prop)) props--;
+    return props == 0;
+  }
+
+  function enterLocalMode(config, state, spec, token) {
+    var pers;
+    if (spec.persistent) for (var p = state.persistentStates; p && !pers; p = p.next)
+      if (spec.spec ? cmp(spec.spec, p.spec) : spec.mode == p.mode) pers = p;
+    var mode = pers ? pers.mode : spec.mode || CodeMirror.getMode(config, spec.spec);
+    var lState = pers ? pers.state : CodeMirror.startState(mode);
+    if (spec.persistent && !pers)
+      state.persistentStates = {mode: mode, spec: spec.spec, state: lState, next: state.persistentStates};
+
+    state.localState = lState;
+    state.local = {mode: mode,
+                   end: spec.end && toRegex(spec.end),
+                   endScan: spec.end && spec.forceEnd !== false && toRegex(spec.end, false),
+                   endToken: token && token.join ? token[token.length - 1] : token};
+  }
+
+  function indexOf(val, arr) {
+    for (var i = 0; i < arr.length; i++) if (arr[i] === val) return true;
+  }
+
+  function indentFunction(states, meta) {
+    return function(state, textAfter, line) {
+      if (state.local && state.local.mode.indent)
+        return state.local.mode.indent(state.localState, textAfter, line);
+      if (state.indent == null || state.local || meta.dontIndentStates && indexOf(state.state, meta.dontIndentStates) > -1)
+        return CodeMirror.Pass;
+
+      var pos = state.indent.length - 1, rules = states[state.state];
+      scan: for (;;) {
+        for (var i = 0; i < rules.length; i++) {
+          var rule = rules[i];
+          if (rule.data.dedent && rule.data.dedentIfLineStart !== false) {
+            var m = rule.regex.exec(textAfter);
+            if (m && m[0]) {
+              pos--;
+              if (rule.next || rule.push) rules = states[rule.next || rule.push];
+              textAfter = textAfter.slice(m[0].length);
+              continue scan;
+            }
+          }
+        }
+        break;
+      }
+      return pos < 0 ? 0 : state.indent[pos];
+    };
+  }
+});
diff --git a/src/main/resources/codemirror/addon/runmode/colorize.js b/src/main/resources/codemirror/addon/runmode/colorize.js
new file mode 100755
index 0000000..eb7060d
--- /dev/null
+++ b/src/main/resources/codemirror/addon/runmode/colorize.js
@@ -0,0 +1,40 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("./runmode"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "./runmode"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var isBlock = /^(p|li|div|h\\d|pre|blockquote|td)$/;
+
+  function textContent(node, out) {
+    if (node.nodeType == 3) return out.push(node.nodeValue);
+    for (var ch = node.firstChild; ch; ch = ch.nextSibling) {
+      textContent(ch, out);
+      if (isBlock.test(node.nodeType)) out.push("\n");
+    }
+  }
+
+  CodeMirror.colorize = function(collection, defaultMode) {
+    if (!collection) collection = document.body.getElementsByTagName("pre");
+
+    for (var i = 0; i < collection.length; ++i) {
+      var node = collection[i];
+      var mode = node.getAttribute("data-lang") || defaultMode;
+      if (!mode) continue;
+
+      var text = [];
+      textContent(node, text);
+      node.innerHTML = "";
+      CodeMirror.runMode(text.join(""), mode, node);
+
+      node.className += " cm-s-default";
+    }
+  };
+});
diff --git a/src/main/resources/codemirror/addon/runmode/runmode-standalone.js b/src/main/resources/codemirror/addon/runmode/runmode-standalone.js
new file mode 100755
index 0000000..f4f352c
--- /dev/null
+++ b/src/main/resources/codemirror/addon/runmode/runmode-standalone.js
@@ -0,0 +1,157 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+window.CodeMirror = {};
+
+(function() {
+"use strict";
+
+function splitLines(string){ return string.split(/\r?\n|\r/); };
+
+function StringStream(string) {
+  this.pos = this.start = 0;
+  this.string = string;
+  this.lineStart = 0;
+}
+StringStream.prototype = {
+  eol: function() {return this.pos >= this.string.length;},
+  sol: function() {return this.pos == 0;},
+  peek: function() {return this.string.charAt(this.pos) || null;},
+  next: function() {
+    if (this.pos < this.string.length)
+      return this.string.charAt(this.pos++);
+  },
+  eat: function(match) {
+    var ch = this.string.charAt(this.pos);
+    if (typeof match == "string") var ok = ch == match;
+    else var ok = ch && (match.test ? match.test(ch) : match(ch));
+    if (ok) {++this.pos; return ch;}
+  },
+  eatWhile: function(match) {
+    var start = this.pos;
+    while (this.eat(match)){}
+    return this.pos > start;
+  },
+  eatSpace: function() {
+    var start = this.pos;
+    while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
+    return this.pos > start;
+  },
+  skipToEnd: function() {this.pos = this.string.length;},
+  skipTo: function(ch) {
+    var found = this.string.indexOf(ch, this.pos);
+    if (found > -1) {this.pos = found; return true;}
+  },
+  backUp: function(n) {this.pos -= n;},
+  column: function() {return this.start - this.lineStart;},
+  indentation: function() {return 0;},
+  match: function(pattern, consume, caseInsensitive) {
+    if (typeof pattern == "string") {
+      var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;};
+      var substr = this.string.substr(this.pos, pattern.length);
+      if (cased(substr) == cased(pattern)) {
+        if (consume !== false) this.pos += pattern.length;
+        return true;
+      }
+    } else {
+      var match = this.string.slice(this.pos).match(pattern);
+      if (match && match.index > 0) return null;
+      if (match && consume !== false) this.pos += match[0].length;
+      return match;
+    }
+  },
+  current: function(){return this.string.slice(this.start, this.pos);},
+  hideFirstChars: function(n, inner) {
+    this.lineStart += n;
+    try { return inner(); }
+    finally { this.lineStart -= n; }
+  }
+};
+CodeMirror.StringStream = StringStream;
+
+CodeMirror.startState = function (mode, a1, a2) {
+  return mode.startState ? mode.startState(a1, a2) : true;
+};
+
+var modes = CodeMirror.modes = {}, mimeModes = CodeMirror.mimeModes = {};
+CodeMirror.defineMode = function (name, mode) {
+  if (arguments.length > 2)
+    mode.dependencies = Array.prototype.slice.call(arguments, 2);
+  modes[name] = mode;
+};
+CodeMirror.defineMIME = function (mime, spec) { mimeModes[mime] = spec; };
+CodeMirror.resolveMode = function(spec) {
+  if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
+    spec = mimeModes[spec];
+  } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
+    spec = mimeModes[spec.name];
+  }
+  if (typeof spec == "string") return {name: spec};
+  else return spec || {name: "null"};
+};
+CodeMirror.getMode = function (options, spec) {
+  spec = CodeMirror.resolveMode(spec);
+  var mfactory = modes[spec.name];
+  if (!mfactory) throw new Error("Unknown mode: " + spec);
+  return mfactory(options, spec);
+};
+CodeMirror.registerHelper = CodeMirror.registerGlobalHelper = Math.min;
+CodeMirror.defineMode("null", function() {
+  return {token: function(stream) {stream.skipToEnd();}};
+});
+CodeMirror.defineMIME("text/plain", "null");
+
+CodeMirror.runMode = function (string, modespec, callback, options) {
+  var mode = CodeMirror.getMode({ indentUnit: 2 }, modespec);
+
+  if (callback.nodeType == 1) {
+    var tabSize = (options && options.tabSize) || 4;
+    var node = callback, col = 0;
+    node.innerHTML = "";
+    callback = function (text, style) {
+      if (text == "\n") {
+        node.appendChild(document.createElement("br"));
+        col = 0;
+        return;
+      }
+      var content = "";
+      // replace tabs
+      for (var pos = 0; ;) {
+        var idx = text.indexOf("\t", pos);
+        if (idx == -1) {
+          content += text.slice(pos);
+          col += text.length - pos;
+          break;
+        } else {
+          col += idx - pos;
+          content += text.slice(pos, idx);
+          var size = tabSize - col % tabSize;
+          col += size;
+          for (var i = 0; i < size; ++i) content += " ";
+          pos = idx + 1;
+        }
+      }
+
+      if (style) {
+        var sp = node.appendChild(document.createElement("span"));
+        sp.className = "cm-" + style.replace(/ +/g, " cm-");
+        sp.appendChild(document.createTextNode(content));
+      } else {
+        node.appendChild(document.createTextNode(content));
+      }
+    };
+  }
+
+  var lines = splitLines(string), state = (options && options.state) || CodeMirror.startState(mode);
+  for (var i = 0, e = lines.length; i < e; ++i) {
+    if (i) callback("\n");
+    var stream = new CodeMirror.StringStream(lines[i]);
+    if (!stream.string && mode.blankLine) mode.blankLine(state);
+    while (!stream.eol()) {
+      var style = mode.token(stream, state);
+      callback(stream.current(), style, i, stream.start, state);
+      stream.start = stream.pos;
+    }
+  }
+};
+})();
diff --git a/src/main/resources/codemirror/addon/runmode/runmode.js b/src/main/resources/codemirror/addon/runmode/runmode.js
new file mode 100755
index 0000000..07d2279
--- /dev/null
+++ b/src/main/resources/codemirror/addon/runmode/runmode.js
@@ -0,0 +1,72 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.runMode = function(string, modespec, callback, options) {
+  var mode = CodeMirror.getMode(CodeMirror.defaults, modespec);
+  var ie = /MSIE \d/.test(navigator.userAgent);
+  var ie_lt9 = ie && (document.documentMode == null || document.documentMode < 9);
+
+  if (callback.nodeType == 1) {
+    var tabSize = (options && options.tabSize) || CodeMirror.defaults.tabSize;
+    var node = callback, col = 0;
+    node.innerHTML = "";
+    callback = function(text, style) {
+      if (text == "\n") {
+        // Emitting LF or CRLF on IE8 or earlier results in an incorrect display.
+        // Emitting a carriage return makes everything ok.
+        node.appendChild(document.createTextNode(ie_lt9 ? '\r' : text));
+        col = 0;
+        return;
+      }
+      var content = "";
+      // replace tabs
+      for (var pos = 0;;) {
+        var idx = text.indexOf("\t", pos);
+        if (idx == -1) {
+          content += text.slice(pos);
+          col += text.length - pos;
+          break;
+        } else {
+          col += idx - pos;
+          content += text.slice(pos, idx);
+          var size = tabSize - col % tabSize;
+          col += size;
+          for (var i = 0; i < size; ++i) content += " ";
+          pos = idx + 1;
+        }
+      }
+
+      if (style) {
+        var sp = node.appendChild(document.createElement("span"));
+        sp.className = "cm-" + style.replace(/ +/g, " cm-");
+        sp.appendChild(document.createTextNode(content));
+      } else {
+        node.appendChild(document.createTextNode(content));
+      }
+    };
+  }
+
+  var lines = CodeMirror.splitLines(string), state = (options && options.state) || CodeMirror.startState(mode);
+  for (var i = 0, e = lines.length; i < e; ++i) {
+    if (i) callback("\n");
+    var stream = new CodeMirror.StringStream(lines[i]);
+    if (!stream.string && mode.blankLine) mode.blankLine(state);
+    while (!stream.eol()) {
+      var style = mode.token(stream, state);
+      callback(stream.current(), style, i, stream.start, state);
+      stream.start = stream.pos;
+    }
+  }
+};
+
+});
diff --git a/src/main/resources/codemirror/addon/runmode/runmode.node.js b/src/main/resources/codemirror/addon/runmode/runmode.node.js
new file mode 100755
index 0000000..8f345a3
--- /dev/null
+++ b/src/main/resources/codemirror/addon/runmode/runmode.node.js
@@ -0,0 +1,178 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+/* Just enough of CodeMirror to run runMode under node.js */
+
+function splitLines(string){return string.split(/\r\n?|\n/);};
+
+// Counts the column offset in a string, taking tabs into account.
+// Used mostly to find indentation.
+var countColumn = function(string, end, tabSize, startIndex, startValue) {
+  if (end == null) {
+    end = string.search(/[^\s\u00a0]/);
+    if (end == -1) end = string.length;
+  }
+  for (var i = startIndex || 0, n = startValue || 0;;) {
+    var nextTab = string.indexOf("\t", i);
+    if (nextTab < 0 || nextTab >= end)
+      return n + (end - i);
+    n += nextTab - i;
+    n += tabSize - (n % tabSize);
+    i = nextTab + 1;
+  }
+};
+
+function StringStream(string, tabSize) {
+  this.pos = this.start = 0;
+  this.string = string;
+  this.tabSize = tabSize || 8;
+  this.lastColumnPos = this.lastColumnValue = 0;
+  this.lineStart = 0;
+};
+
+StringStream.prototype = {
+  eol: function() {return this.pos >= this.string.length;},
+  sol: function() {return this.pos == this.lineStart;},
+  peek: function() {return this.string.charAt(this.pos) || undefined;},
+  next: function() {
+    if (this.pos < this.string.length)
+      return this.string.charAt(this.pos++);
+  },
+  eat: function(match) {
+    var ch = this.string.charAt(this.pos);
+    if (typeof match == "string") var ok = ch == match;
+    else var ok = ch && (match.test ? match.test(ch) : match(ch));
+    if (ok) {++this.pos; return ch;}
+  },
+  eatWhile: function(match) {
+    var start = this.pos;
+    while (this.eat(match)){}
+    return this.pos > start;
+  },
+  eatSpace: function() {
+    var start = this.pos;
+    while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
+    return this.pos > start;
+  },
+  skipToEnd: function() {this.pos = this.string.length;},
+  skipTo: function(ch) {
+    var found = this.string.indexOf(ch, this.pos);
+    if (found > -1) {this.pos = found; return true;}
+  },
+  backUp: function(n) {this.pos -= n;},
+  column: function() {
+    if (this.lastColumnPos < this.start) {
+      this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);
+      this.lastColumnPos = this.start;
+    }
+    return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);
+  },
+  indentation: function() {
+    return countColumn(this.string, null, this.tabSize) -
+      (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);
+  },
+  match: function(pattern, consume, caseInsensitive) {
+    if (typeof pattern == "string") {
+      var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;};
+      var substr = this.string.substr(this.pos, pattern.length);
+      if (cased(substr) == cased(pattern)) {
+        if (consume !== false) this.pos += pattern.length;
+        return true;
+      }
+    } else {
+      var match = this.string.slice(this.pos).match(pattern);
+      if (match && match.index > 0) return null;
+      if (match && consume !== false) this.pos += match[0].length;
+      return match;
+    }
+  },
+  current: function(){return this.string.slice(this.start, this.pos);},
+  hideFirstChars: function(n, inner) {
+    this.lineStart += n;
+    try { return inner(); }
+    finally { this.lineStart -= n; }
+  }
+};
+exports.StringStream = StringStream;
+
+exports.startState = function(mode, a1, a2) {
+  return mode.startState ? mode.startState(a1, a2) : true;
+};
+
+var modes = exports.modes = {}, mimeModes = exports.mimeModes = {};
+exports.defineMode = function(name, mode) {
+  if (arguments.length > 2)
+    mode.dependencies = Array.prototype.slice.call(arguments, 2);
+  modes[name] = mode;
+};
+exports.defineMIME = function(mime, spec) { mimeModes[mime] = spec; };
+
+exports.defineMode("null", function() {
+  return {token: function(stream) {stream.skipToEnd();}};
+});
+exports.defineMIME("text/plain", "null");
+
+exports.resolveMode = function(spec) {
+  if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
+    spec = mimeModes[spec];
+  } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
+    spec = mimeModes[spec.name];
+  }
+  if (typeof spec == "string") return {name: spec};
+  else return spec || {name: "null"};
+};
+
+function copyObj(obj, target, overwrite) {
+  if (!target) target = {};
+  for (var prop in obj)
+    if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
+      target[prop] = obj[prop];
+  return target;
+}
+
+// This can be used to attach properties to mode objects from
+// outside the actual mode definition.
+var modeExtensions = exports.modeExtensions = {};
+exports.extendMode = function(mode, properties) {
+  var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});
+  copyObj(properties, exts);
+};
+
+exports.getMode = function(options, spec) {
+  var spec = exports.resolveMode(spec);
+  var mfactory = modes[spec.name];
+  if (!mfactory) return exports.getMode(options, "text/plain");
+  var modeObj = mfactory(options, spec);
+  if (modeExtensions.hasOwnProperty(spec.name)) {
+    var exts = modeExtensions[spec.name];
+    for (var prop in exts) {
+      if (!exts.hasOwnProperty(prop)) continue;
+      if (modeObj.hasOwnProperty(prop)) modeObj["_" + prop] = modeObj[prop];
+      modeObj[prop] = exts[prop];
+    }
+  }
+  modeObj.name = spec.name;
+  if (spec.helperType) modeObj.helperType = spec.helperType;
+  if (spec.modeProps) for (var prop in spec.modeProps)
+    modeObj[prop] = spec.modeProps[prop];
+
+  return modeObj;
+};
+exports.registerHelper = exports.registerGlobalHelper = Math.min;
+
+exports.runMode = function(string, modespec, callback, options) {
+  var mode = exports.getMode({indentUnit: 2}, modespec);
+  var lines = splitLines(string), state = (options && options.state) || exports.startState(mode);
+  for (var i = 0, e = lines.length; i < e; ++i) {
+    if (i) callback("\n");
+    var stream = new exports.StringStream(lines[i]);
+    if (!stream.string && mode.blankLine) mode.blankLine(state);
+    while (!stream.eol()) {
+      var style = mode.token(stream, state);
+      callback(stream.current(), style, i, stream.start, state);
+      stream.start = stream.pos;
+    }
+  }
+};
+
+require.cache[require.resolve("../../lib/codemirror")] = require.cache[require.resolve("./runmode.node")];
diff --git a/src/main/resources/codemirror/addon/scroll/annotatescrollbar.js b/src/main/resources/codemirror/addon/scroll/annotatescrollbar.js
new file mode 100755
index 0000000..e62a45a
--- /dev/null
+++ b/src/main/resources/codemirror/addon/scroll/annotatescrollbar.js
@@ -0,0 +1,115 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineExtension("annotateScrollbar", function(options) {
+    if (typeof options == "string") options = {className: options};
+    return new Annotation(this, options);
+  });
+
+  CodeMirror.defineOption("scrollButtonHeight", 0);
+
+  function Annotation(cm, options) {
+    this.cm = cm;
+    this.options = options;
+    this.buttonHeight = options.scrollButtonHeight || cm.getOption("scrollButtonHeight");
+    this.annotations = [];
+    this.doRedraw = this.doUpdate = null;
+    this.div = cm.getWrapperElement().appendChild(document.createElement("div"));
+    this.div.style.cssText = "position: absolute; right: 0; top: 0; z-index: 7; pointer-events: none";
+    this.computeScale();
+
+    function scheduleRedraw(delay) {
+      clearTimeout(self.doRedraw);
+      self.doRedraw = setTimeout(function() { self.redraw(); }, delay);
+    }
+
+    var self = this;
+    cm.on("refresh", this.resizeHandler = function() {
+      clearTimeout(self.doUpdate);
+      self.doUpdate = setTimeout(function() {
+        if (self.computeScale()) scheduleRedraw(20);
+      }, 100);
+    });
+    cm.on("markerAdded", this.resizeHandler);
+    cm.on("markerCleared", this.resizeHandler);
+    if (options.listenForChanges !== false)
+      cm.on("change", this.changeHandler = function() {
+        scheduleRedraw(250);
+      });
+  }
+
+  Annotation.prototype.computeScale = function() {
+    var cm = this.cm;
+    var hScale = (cm.getWrapperElement().clientHeight - cm.display.barHeight - this.buttonHeight * 2) /
+      cm.heightAtLine(cm.lastLine() + 1, "local");
+    if (hScale != this.hScale) {
+      this.hScale = hScale;
+      return true;
+    }
+  };
+
+  Annotation.prototype.update = function(annotations) {
+    this.annotations = annotations;
+    this.redraw();
+  };
+
+  Annotation.prototype.redraw = function(compute) {
+    if (compute !== false) this.computeScale();
+    var cm = this.cm, hScale = this.hScale;
+
+    var frag = document.createDocumentFragment(), anns = this.annotations;
+
+    var wrapping = cm.getOption("lineWrapping");
+    var singleLineH = wrapping && cm.defaultTextHeight() * 1.5;
+    var curLine = null, curLineObj = null;
+    function getY(pos, top) {
+      if (curLine != pos.line) {
+        curLine = pos.line;
+        curLineObj = cm.getLineHandle(curLine);
+      }
+      if (wrapping && curLineObj.height > singleLineH)
+        return cm.charCoords(pos, "local")[top ? "top" : "bottom"];
+      var topY = cm.heightAtLine(curLineObj, "local");
+      return topY + (top ? 0 : curLineObj.height);
+    }
+
+    if (cm.display.barWidth) for (var i = 0, nextTop; i < anns.length; i++) {
+      var ann = anns[i];
+      var top = nextTop || getY(ann.from, true) * hScale;
+      var bottom = getY(ann.to, false) * hScale;
+      while (i < anns.length - 1) {
+        nextTop = getY(anns[i + 1].from, true) * hScale;
+        if (nextTop > bottom + .9) break;
+        ann = anns[++i];
+        bottom = getY(ann.to, false) * hScale;
+      }
+      if (bottom == top) continue;
+      var height = Math.max(bottom - top, 3);
+
+      var elt = frag.appendChild(document.createElement("div"));
+      elt.style.cssText = "position: absolute; right: 0px; width: " + Math.max(cm.display.barWidth - 1, 2) + "px; top: "
+        + (top + this.buttonHeight) + "px; height: " + height + "px";
+      elt.className = this.options.className;
+    }
+    this.div.textContent = "";
+    this.div.appendChild(frag);
+  };
+
+  Annotation.prototype.clear = function() {
+    this.cm.off("refresh", this.resizeHandler);
+    this.cm.off("markerAdded", this.resizeHandler);
+    this.cm.off("markerCleared", this.resizeHandler);
+    if (this.changeHandler) this.cm.off("change", this.changeHandler);
+    this.div.parentNode.removeChild(this.div);
+  };
+});
diff --git a/src/main/resources/codemirror/addon/scroll/scrollpastend.js b/src/main/resources/codemirror/addon/scroll/scrollpastend.js
new file mode 100755
index 0000000..008ae4c
--- /dev/null
+++ b/src/main/resources/codemirror/addon/scroll/scrollpastend.js
@@ -0,0 +1,46 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineOption("scrollPastEnd", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      cm.off("change", onChange);
+      cm.off("refresh", updateBottomMargin);
+      cm.display.lineSpace.parentNode.style.paddingBottom = "";
+      cm.state.scrollPastEndPadding = null;
+    }
+    if (val) {
+      cm.on("change", onChange);
+      cm.on("refresh", updateBottomMargin);
+      updateBottomMargin(cm);
+    }
+  });
+
+  function onChange(cm, change) {
+    if (CodeMirror.changeEnd(change).line == cm.lastLine())
+      updateBottomMargin(cm);
+  }
+
+  function updateBottomMargin(cm) {
+    var padding = "";
+    if (cm.lineCount() > 1) {
+      var totalH = cm.display.scroller.clientHeight - 30,
+          lastLineH = cm.getLineHandle(cm.lastLine()).height;
+      padding = (totalH - lastLineH) + "px";
+    }
+    if (cm.state.scrollPastEndPadding != padding) {
+      cm.state.scrollPastEndPadding = padding;
+      cm.display.lineSpace.parentNode.style.paddingBottom = padding;
+      cm.setSize();
+    }
+  }
+});
diff --git a/src/main/resources/codemirror/addon/scroll/simplescrollbars.css b/src/main/resources/codemirror/addon/scroll/simplescrollbars.css
new file mode 100755
index 0000000..5eea7aa
--- /dev/null
+++ b/src/main/resources/codemirror/addon/scroll/simplescrollbars.css
@@ -0,0 +1,66 @@
+.CodeMirror-simplescroll-horizontal div, .CodeMirror-simplescroll-vertical div {
+  position: absolute;
+  background: #ccc;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  border: 1px solid #bbb;
+  border-radius: 2px;
+}
+
+.CodeMirror-simplescroll-horizontal, .CodeMirror-simplescroll-vertical {
+  position: absolute;
+  z-index: 6;
+  background: #eee;
+}
+
+.CodeMirror-simplescroll-horizontal {
+  bottom: 0; left: 0;
+  height: 8px;
+}
+.CodeMirror-simplescroll-horizontal div {
+  bottom: 0;
+  height: 100%;
+}
+
+.CodeMirror-simplescroll-vertical {
+  right: 0; top: 0;
+  width: 8px;
+}
+.CodeMirror-simplescroll-vertical div {
+  right: 0;
+  width: 100%;
+}
+
+
+.CodeMirror-overlayscroll .CodeMirror-scrollbar-filler, .CodeMirror-overlayscroll .CodeMirror-gutter-filler {
+  display: none;
+}
+
+.CodeMirror-overlayscroll-horizontal div, .CodeMirror-overlayscroll-vertical div {
+  position: absolute;
+  background: #bcd;
+  border-radius: 3px;
+}
+
+.CodeMirror-overlayscroll-horizontal, .CodeMirror-overlayscroll-vertical {
+  position: absolute;
+  z-index: 6;
+}
+
+.CodeMirror-overlayscroll-horizontal {
+  bottom: 0; left: 0;
+  height: 6px;
+}
+.CodeMirror-overlayscroll-horizontal div {
+  bottom: 0;
+  height: 100%;
+}
+
+.CodeMirror-overlayscroll-vertical {
+  right: 0; top: 0;
+  width: 6px;
+}
+.CodeMirror-overlayscroll-vertical div {
+  right: 0;
+  width: 100%;
+}
diff --git a/src/main/resources/codemirror/addon/scroll/simplescrollbars.js b/src/main/resources/codemirror/addon/scroll/simplescrollbars.js
new file mode 100755
index 0000000..f78353a
--- /dev/null
+++ b/src/main/resources/codemirror/addon/scroll/simplescrollbars.js
@@ -0,0 +1,147 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  function Bar(cls, orientation, scroll) {
+    this.orientation = orientation;
+    this.scroll = scroll;
+    this.screen = this.total = this.size = 1;
+    this.pos = 0;
+
+    this.node = document.createElement("div");
+    this.node.className = cls + "-" + orientation;
+    this.inner = this.node.appendChild(document.createElement("div"));
+
+    var self = this;
+    CodeMirror.on(this.inner, "mousedown", function(e) {
+      if (e.which != 1) return;
+      CodeMirror.e_preventDefault(e);
+      var axis = self.orientation == "horizontal" ? "pageX" : "pageY";
+      var start = e[axis], startpos = self.pos;
+      function done() {
+        CodeMirror.off(document, "mousemove", move);
+        CodeMirror.off(document, "mouseup", done);
+      }
+      function move(e) {
+        if (e.which != 1) return done();
+        self.moveTo(startpos + (e[axis] - start) * (self.total / self.size));
+      }
+      CodeMirror.on(document, "mousemove", move);
+      CodeMirror.on(document, "mouseup", done);
+    });
+
+    CodeMirror.on(this.node, "click", function(e) {
+      CodeMirror.e_preventDefault(e);
+      var innerBox = self.inner.getBoundingClientRect(), where;
+      if (self.orientation == "horizontal")
+        where = e.clientX < innerBox.left ? -1 : e.clientX > innerBox.right ? 1 : 0;
+      else
+        where = e.clientY < innerBox.top ? -1 : e.clientY > innerBox.bottom ? 1 : 0;
+      self.moveTo(self.pos + where * self.screen);
+    });
+
+    function onWheel(e) {
+      var moved = CodeMirror.wheelEventPixels(e)[self.orientation == "horizontal" ? "x" : "y"];
+      var oldPos = self.pos;
+      self.moveTo(self.pos + moved);
+      if (self.pos != oldPos) CodeMirror.e_preventDefault(e);
+    }
+    CodeMirror.on(this.node, "mousewheel", onWheel);
+    CodeMirror.on(this.node, "DOMMouseScroll", onWheel);
+  }
+
+  Bar.prototype.moveTo = function(pos, update) {
+    if (pos < 0) pos = 0;
+    if (pos > this.total - this.screen) pos = this.total - this.screen;
+    if (pos == this.pos) return;
+    this.pos = pos;
+    this.inner.style[this.orientation == "horizontal" ? "left" : "top"] =
+      (pos * (this.size / this.total)) + "px";
+    if (update !== false) this.scroll(pos, this.orientation);
+  };
+
+  var minButtonSize = 10;
+
+  Bar.prototype.update = function(scrollSize, clientSize, barSize) {
+    this.screen = clientSize;
+    this.total = scrollSize;
+    this.size = barSize;
+
+    var buttonSize = this.screen * (this.size / this.total);
+    if (buttonSize < minButtonSize) {
+      this.size -= minButtonSize - buttonSize;
+      buttonSize = minButtonSize;
+    }
+    this.inner.style[this.orientation == "horizontal" ? "width" : "height"] =
+      buttonSize + "px";
+    this.inner.style[this.orientation == "horizontal" ? "left" : "top"] =
+      this.pos * (this.size / this.total) + "px";
+  };
+
+  function SimpleScrollbars(cls, place, scroll) {
+    this.addClass = cls;
+    this.horiz = new Bar(cls, "horizontal", scroll);
+    place(this.horiz.node);
+    this.vert = new Bar(cls, "vertical", scroll);
+    place(this.vert.node);
+    this.width = null;
+  }
+
+  SimpleScrollbars.prototype.update = function(measure) {
+    if (this.width == null) {
+      var style = window.getComputedStyle ? window.getComputedStyle(this.horiz.node) : this.horiz.node.currentStyle;
+      if (style) this.width = parseInt(style.height);
+    }
+    var width = this.width || 0;
+
+    var needsH = measure.scrollWidth > measure.clientWidth + 1;
+    var needsV = measure.scrollHeight > measure.clientHeight + 1;
+    this.vert.node.style.display = needsV ? "block" : "none";
+    this.horiz.node.style.display = needsH ? "block" : "none";
+
+    if (needsV) {
+      this.vert.update(measure.scrollHeight, measure.clientHeight,
+                       measure.viewHeight - (needsH ? width : 0));
+      this.vert.node.style.display = "block";
+      this.vert.node.style.bottom = needsH ? width + "px" : "0";
+    }
+    if (needsH) {
+      this.horiz.update(measure.scrollWidth, measure.clientWidth,
+                        measure.viewWidth - (needsV ? width : 0) - measure.barLeft);
+      this.horiz.node.style.right = needsV ? width + "px" : "0";
+      this.horiz.node.style.left = measure.barLeft + "px";
+    }
+
+    return {right: needsV ? width : 0, bottom: needsH ? width : 0};
+  };
+
+  SimpleScrollbars.prototype.setScrollTop = function(pos) {
+    this.vert.moveTo(pos, false);
+  };
+
+  SimpleScrollbars.prototype.setScrollLeft = function(pos) {
+    this.horiz.moveTo(pos, false);
+  };
+
+  SimpleScrollbars.prototype.clear = function() {
+    var parent = this.horiz.node.parentNode;
+    parent.removeChild(this.horiz.node);
+    parent.removeChild(this.vert.node);
+  };
+
+  CodeMirror.scrollbarModel.simple = function(place, scroll) {
+    return new SimpleScrollbars("CodeMirror-simplescroll", place, scroll);
+  };
+  CodeMirror.scrollbarModel.overlay = function(place, scroll) {
+    return new SimpleScrollbars("CodeMirror-overlayscroll", place, scroll);
+  };
+});
diff --git a/src/main/resources/codemirror/addon/search/match-highlighter.js b/src/main/resources/codemirror/addon/search/match-highlighter.js
new file mode 100755
index 0000000..e9a2272
--- /dev/null
+++ b/src/main/resources/codemirror/addon/search/match-highlighter.js
@@ -0,0 +1,128 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Highlighting text that matches the selection
+//
+// Defines an option highlightSelectionMatches, which, when enabled,
+// will style strings that match the selection throughout the
+// document.
+//
+// The option can be set to true to simply enable it, or to a
+// {minChars, style, wordsOnly, showToken, delay} object to explicitly
+// configure it. minChars is the minimum amount of characters that should be
+// selected for the behavior to occur, and style is the token style to
+// apply to the matches. This will be prefixed by "cm-" to create an
+// actual CSS class name. If wordsOnly is enabled, the matches will be
+// highlighted only if the selected text is a word. showToken, when enabled,
+// will cause the current token to be highlighted when nothing is selected.
+// delay is used to specify how much time to wait, in milliseconds, before
+// highlighting the matches.
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var DEFAULT_MIN_CHARS = 2;
+  var DEFAULT_TOKEN_STYLE = "matchhighlight";
+  var DEFAULT_DELAY = 100;
+  var DEFAULT_WORDS_ONLY = false;
+
+  function State(options) {
+    if (typeof options == "object") {
+      this.minChars = options.minChars;
+      this.style = options.style;
+      this.showToken = options.showToken;
+      this.delay = options.delay;
+      this.wordsOnly = options.wordsOnly;
+    }
+    if (this.style == null) this.style = DEFAULT_TOKEN_STYLE;
+    if (this.minChars == null) this.minChars = DEFAULT_MIN_CHARS;
+    if (this.delay == null) this.delay = DEFAULT_DELAY;
+    if (this.wordsOnly == null) this.wordsOnly = DEFAULT_WORDS_ONLY;
+    this.overlay = this.timeout = null;
+  }
+
+  CodeMirror.defineOption("highlightSelectionMatches", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      var over = cm.state.matchHighlighter.overlay;
+      if (over) cm.removeOverlay(over);
+      clearTimeout(cm.state.matchHighlighter.timeout);
+      cm.state.matchHighlighter = null;
+      cm.off("cursorActivity", cursorActivity);
+    }
+    if (val) {
+      cm.state.matchHighlighter = new State(val);
+      highlightMatches(cm);
+      cm.on("cursorActivity", cursorActivity);
+    }
+  });
+
+  function cursorActivity(cm) {
+    var state = cm.state.matchHighlighter;
+    clearTimeout(state.timeout);
+    state.timeout = setTimeout(function() {highlightMatches(cm);}, state.delay);
+  }
+
+  function highlightMatches(cm) {
+    cm.operation(function() {
+      var state = cm.state.matchHighlighter;
+      if (state.overlay) {
+        cm.removeOverlay(state.overlay);
+        state.overlay = null;
+      }
+      if (!cm.somethingSelected() && state.showToken) {
+        var re = state.showToken === true ? /[\w$]/ : state.showToken;
+        var cur = cm.getCursor(), line = cm.getLine(cur.line), start = cur.ch, end = start;
+        while (start && re.test(line.charAt(start - 1))) --start;
+        while (end < line.length && re.test(line.charAt(end))) ++end;
+        if (start < end)
+          cm.addOverlay(state.overlay = makeOverlay(line.slice(start, end), re, state.style));
+        return;
+      }
+      var from = cm.getCursor("from"), to = cm.getCursor("to");
+      if (from.line != to.line) return;
+      if (state.wordsOnly && !isWord(cm, from, to)) return;
+      var selection = cm.getRange(from, to).replace(/^\s+|\s+$/g, "");
+      if (selection.length >= state.minChars)
+        cm.addOverlay(state.overlay = makeOverlay(selection, false, state.style));
+    });
+  }
+
+  function isWord(cm, from, to) {
+    var str = cm.getRange(from, to);
+    if (str.match(/^\w+$/) !== null) {
+        if (from.ch > 0) {
+            var pos = {line: from.line, ch: from.ch - 1};
+            var chr = cm.getRange(pos, from);
+            if (chr.match(/\W/) === null) return false;
+        }
+        if (to.ch < cm.getLine(from.line).length) {
+            var pos = {line: to.line, ch: to.ch + 1};
+            var chr = cm.getRange(to, pos);
+            if (chr.match(/\W/) === null) return false;
+        }
+        return true;
+    } else return false;
+  }
+
+  function boundariesAround(stream, re) {
+    return (!stream.start || !re.test(stream.string.charAt(stream.start - 1))) &&
+      (stream.pos == stream.string.length || !re.test(stream.string.charAt(stream.pos)));
+  }
+
+  function makeOverlay(query, hasBoundary, style) {
+    return {token: function(stream) {
+      if (stream.match(query) &&
+          (!hasBoundary || boundariesAround(stream, hasBoundary)))
+        return style;
+      stream.next();
+      stream.skipTo(query.charAt(0)) || stream.skipToEnd();
+    }};
+  }
+});
diff --git a/src/main/resources/codemirror/addon/search/matchesonscrollbar.css b/src/main/resources/codemirror/addon/search/matchesonscrollbar.css
new file mode 100755
index 0000000..77932cc
--- /dev/null
+++ b/src/main/resources/codemirror/addon/search/matchesonscrollbar.css
@@ -0,0 +1,8 @@
+.CodeMirror-search-match {
+  background: gold;
+  border-top: 1px solid orange;
+  border-bottom: 1px solid orange;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  opacity: .5;
+}
diff --git a/src/main/resources/codemirror/addon/search/matchesonscrollbar.js b/src/main/resources/codemirror/addon/search/matchesonscrollbar.js
new file mode 100755
index 0000000..8d19228
--- /dev/null
+++ b/src/main/resources/codemirror/addon/search/matchesonscrollbar.js
@@ -0,0 +1,97 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("./searchcursor"), require("../scroll/annotatescrollbar"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "./searchcursor", "../scroll/annotatescrollbar"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineExtension("showMatchesOnScrollbar", function(query, caseFold, options) {
+    if (typeof options == "string") options = {className: options};
+    if (!options) options = {};
+    return new SearchAnnotation(this, query, caseFold, options);
+  });
+
+  function SearchAnnotation(cm, query, caseFold, options) {
+    this.cm = cm;
+    this.options = options;
+    var annotateOptions = {listenForChanges: false};
+    for (var prop in options) annotateOptions[prop] = options[prop];
+    if (!annotateOptions.className) annotateOptions.className = "CodeMirror-search-match";
+    this.annotation = cm.annotateScrollbar(annotateOptions);
+    this.query = query;
+    this.caseFold = caseFold;
+    this.gap = {from: cm.firstLine(), to: cm.lastLine() + 1};
+    this.matches = [];
+    this.update = null;
+
+    this.findMatches();
+    this.annotation.update(this.matches);
+
+    var self = this;
+    cm.on("change", this.changeHandler = function(_cm, change) { self.onChange(change); });
+  }
+
+  var MAX_MATCHES = 1000;
+
+  SearchAnnotation.prototype.findMatches = function() {
+    if (!this.gap) return;
+    for (var i = 0; i < this.matches.length; i++) {
+      var match = this.matches[i];
+      if (match.from.line >= this.gap.to) break;
+      if (match.to.line >= this.gap.from) this.matches.splice(i--, 1);
+    }
+    var cursor = this.cm.getSearchCursor(this.query, CodeMirror.Pos(this.gap.from, 0), this.caseFold);
+    var maxMatches = this.options && this.options.maxMatches || MAX_MATCHES;
+    while (cursor.findNext()) {
+      var match = {from: cursor.from(), to: cursor.to()};
+      if (match.from.line >= this.gap.to) break;
+      this.matches.splice(i++, 0, match);
+      if (this.matches.length > maxMatches) break;
+    }
+    this.gap = null;
+  };
+
+  function offsetLine(line, changeStart, sizeChange) {
+    if (line <= changeStart) return line;
+    return Math.max(changeStart, line + sizeChange);
+  }
+
+  SearchAnnotation.prototype.onChange = function(change) {
+    var startLine = change.from.line;
+    var endLine = CodeMirror.changeEnd(change).line;
+    var sizeChange = endLine - change.to.line;
+    if (this.gap) {
+      this.gap.from = Math.min(offsetLine(this.gap.from, startLine, sizeChange), change.from.line);
+      this.gap.to = Math.max(offsetLine(this.gap.to, startLine, sizeChange), change.from.line);
+    } else {
+      this.gap = {from: change.from.line, to: endLine + 1};
+    }
+
+    if (sizeChange) for (var i = 0; i < this.matches.length; i++) {
+      var match = this.matches[i];
+      var newFrom = offsetLine(match.from.line, startLine, sizeChange);
+      if (newFrom != match.from.line) match.from = CodeMirror.Pos(newFrom, match.from.ch);
+      var newTo = offsetLine(match.to.line, startLine, sizeChange);
+      if (newTo != match.to.line) match.to = CodeMirror.Pos(newTo, match.to.ch);
+    }
+    clearTimeout(this.update);
+    var self = this;
+    this.update = setTimeout(function() { self.updateAfterChange(); }, 250);
+  };
+
+  SearchAnnotation.prototype.updateAfterChange = function() {
+    this.findMatches();
+    this.annotation.update(this.matches);
+  };
+
+  SearchAnnotation.prototype.clear = function() {
+    this.cm.off("change", this.changeHandler);
+    this.annotation.clear();
+  };
+});
diff --git a/src/main/resources/codemirror/addon/search/search.js b/src/main/resources/codemirror/addon/search/search.js
new file mode 100755
index 0000000..761cb94
--- /dev/null
+++ b/src/main/resources/codemirror/addon/search/search.js
@@ -0,0 +1,167 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Define search commands. Depends on dialog.js or another
+// implementation of the openDialog method.
+
+// Replace works a little oddly -- it will do the replace on the next
+// Ctrl-G (or whatever is bound to findNext) press. You prevent a
+// replace by making sure the match is no longer selected when hitting
+// Ctrl-G.
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("./searchcursor"), require("../dialog/dialog"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "./searchcursor", "../dialog/dialog"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+  function searchOverlay(query, caseInsensitive) {
+    if (typeof query == "string")
+      query = new RegExp(query.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"), caseInsensitive ? "gi" : "g");
+    else if (!query.global)
+      query = new RegExp(query.source, query.ignoreCase ? "gi" : "g");
+
+    return {token: function(stream) {
+      query.lastIndex = stream.pos;
+      var match = query.exec(stream.string);
+      if (match && match.index == stream.pos) {
+        stream.pos += match[0].length;
+        return "searching";
+      } else if (match) {
+        stream.pos = match.index;
+      } else {
+        stream.skipToEnd();
+      }
+    }};
+  }
+
+  function SearchState() {
+    this.posFrom = this.posTo = this.lastQuery = this.query = null;
+    this.overlay = null;
+  }
+  function getSearchState(cm) {
+    return cm.state.search || (cm.state.search = new SearchState());
+  }
+  function queryCaseInsensitive(query) {
+    return typeof query == "string" && query == query.toLowerCase();
+  }
+  function getSearchCursor(cm, query, pos) {
+    // Heuristic: if the query string is all lowercase, do a case insensitive search.
+    return cm.getSearchCursor(query, pos, queryCaseInsensitive(query));
+  }
+  function dialog(cm, text, shortText, deflt, f) {
+    if (cm.openDialog) cm.openDialog(text, f, {value: deflt, selectValueOnOpen: true});
+    else f(prompt(shortText, deflt));
+  }
+  function confirmDialog(cm, text, shortText, fs) {
+    if (cm.openConfirm) cm.openConfirm(text, fs);
+    else if (confirm(shortText)) fs[0]();
+  }
+  function parseQuery(query) {
+    var isRE = query.match(/^\/(.*)\/([a-z]*)$/);
+    if (isRE) {
+      try { query = new RegExp(isRE[1], isRE[2].indexOf("i") == -1 ? "" : "i"); }
+      catch(e) {} // Not a regular expression after all, do a string search
+    }
+    if (typeof query == "string" ? query == "" : query.test(""))
+      query = /x^/;
+    return query;
+  }
+  var queryDialog =
+    'Search: <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">(Use /re/ syntax for regexp search)</span>';
+  function doSearch(cm, rev) {
+    var state = getSearchState(cm);
+    if (state.query) return findNext(cm, rev);
+    var q = cm.getSelection() || state.lastQuery;
+    dialog(cm, queryDialog, "Search for:", q, function(query) {
+      cm.operation(function() {
+        if (!query || state.query) return;
+        state.query = parseQuery(query);
+        cm.removeOverlay(state.overlay, queryCaseInsensitive(state.query));
+        state.overlay = searchOverlay(state.query, queryCaseInsensitive(state.query));
+        cm.addOverlay(state.overlay);
+        if (cm.showMatchesOnScrollbar) {
+          if (state.annotate) { state.annotate.clear(); state.annotate = null; }
+          state.annotate = cm.showMatchesOnScrollbar(state.query, queryCaseInsensitive(state.query));
+        }
+        state.posFrom = state.posTo = cm.getCursor();
+        findNext(cm, rev);
+      });
+    });
+  }
+  function findNext(cm, rev) {cm.operation(function() {
+    var state = getSearchState(cm);
+    var cursor = getSearchCursor(cm, state.query, rev ? state.posFrom : state.posTo);
+    if (!cursor.find(rev)) {
+      cursor = getSearchCursor(cm, state.query, rev ? CodeMirror.Pos(cm.lastLine()) : CodeMirror.Pos(cm.firstLine(), 0));
+      if (!cursor.find(rev)) return;
+    }
+    cm.setSelection(cursor.from(), cursor.to());
+    cm.scrollIntoView({from: cursor.from(), to: cursor.to()});
+    state.posFrom = cursor.from(); state.posTo = cursor.to();
+  });}
+  function clearSearch(cm) {cm.operation(function() {
+    var state = getSearchState(cm);
+    state.lastQuery = state.query;
+    if (!state.query) return;
+    state.query = null;
+    cm.removeOverlay(state.overlay);
+    if (state.annotate) { state.annotate.clear(); state.annotate = null; }
+  });}
+
+  var replaceQueryDialog =
+    'Replace: <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">(Use /re/ syntax for regexp search)</span>';
+  var replacementQueryDialog = 'With: <input type="text" style="width: 10em" class="CodeMirror-search-field"/>';
+  var doReplaceConfirm = "Replace? <button>Yes</button> <button>No</button> <button>Stop</button>";
+  function replace(cm, all) {
+    if (cm.getOption("readOnly")) return;
+    var query = cm.getSelection() || getSearchState(cm).lastQuery;
+    dialog(cm, replaceQueryDialog, "Replace:", query, function(query) {
+      if (!query) return;
+      query = parseQuery(query);
+      dialog(cm, replacementQueryDialog, "Replace with:", "", function(text) {
+        if (all) {
+          cm.operation(function() {
+            for (var cursor = getSearchCursor(cm, query); cursor.findNext();) {
+              if (typeof query != "string") {
+                var match = cm.getRange(cursor.from(), cursor.to()).match(query);
+                cursor.replace(text.replace(/\$(\d)/g, function(_, i) {return match[i];}));
+              } else cursor.replace(text);
+            }
+          });
+        } else {
+          clearSearch(cm);
+          var cursor = getSearchCursor(cm, query, cm.getCursor());
+          var advance = function() {
+            var start = cursor.from(), match;
+            if (!(match = cursor.findNext())) {
+              cursor = getSearchCursor(cm, query);
+              if (!(match = cursor.findNext()) ||
+                  (start && cursor.from().line == start.line && cursor.from().ch == start.ch)) return;
+            }
+            cm.setSelection(cursor.from(), cursor.to());
+            cm.scrollIntoView({from: cursor.from(), to: cursor.to()});
+            confirmDialog(cm, doReplaceConfirm, "Replace?",
+                          [function() {doReplace(match);}, advance]);
+          };
+          var doReplace = function(match) {
+            cursor.replace(typeof query == "string" ? text :
+                           text.replace(/\$(\d)/g, function(_, i) {return match[i];}));
+            advance();
+          };
+          advance();
+        }
+      });
+    });
+  }
+
+  CodeMirror.commands.find = function(cm) {clearSearch(cm); doSearch(cm);};
+  CodeMirror.commands.findNext = doSearch;
+  CodeMirror.commands.findPrev = function(cm) {doSearch(cm, true);};
+  CodeMirror.commands.clearSearch = clearSearch;
+  CodeMirror.commands.replace = replace;
+  CodeMirror.commands.replaceAll = function(cm) {replace(cm, true);};
+});
diff --git a/src/main/resources/codemirror/addon/search/searchcursor.js b/src/main/resources/codemirror/addon/search/searchcursor.js
new file mode 100755
index 0000000..b70242e
--- /dev/null
+++ b/src/main/resources/codemirror/addon/search/searchcursor.js
@@ -0,0 +1,189 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+  var Pos = CodeMirror.Pos;
+
+  function SearchCursor(doc, query, pos, caseFold) {
+    this.atOccurrence = false; this.doc = doc;
+    if (caseFold == null && typeof query == "string") caseFold = false;
+
+    pos = pos ? doc.clipPos(pos) : Pos(0, 0);
+    this.pos = {from: pos, to: pos};
+
+    // The matches method is filled in based on the type of query.
+    // It takes a position and a direction, and returns an object
+    // describing the next occurrence of the query, or null if no
+    // more matches were found.
+    if (typeof query != "string") { // Regexp match
+      if (!query.global) query = new RegExp(query.source, query.ignoreCase ? "ig" : "g");
+      this.matches = function(reverse, pos) {
+        if (reverse) {
+          query.lastIndex = 0;
+          var line = doc.getLine(pos.line).slice(0, pos.ch), cutOff = 0, match, start;
+          for (;;) {
+            query.lastIndex = cutOff;
+            var newMatch = query.exec(line);
+            if (!newMatch) break;
+            match = newMatch;
+            start = match.index;
+            cutOff = match.index + (match[0].length || 1);
+            if (cutOff == line.length) break;
+          }
+          var matchLen = (match && match[0].length) || 0;
+          if (!matchLen) {
+            if (start == 0 && line.length == 0) {match = undefined;}
+            else if (start != doc.getLine(pos.line).length) {
+              matchLen++;
+            }
+          }
+        } else {
+          query.lastIndex = pos.ch;
+          var line = doc.getLine(pos.line), match = query.exec(line);
+          var matchLen = (match && match[0].length) || 0;
+          var start = match && match.index;
+          if (start + matchLen != line.length && !matchLen) matchLen = 1;
+        }
+        if (match && matchLen)
+          return {from: Pos(pos.line, start),
+                  to: Pos(pos.line, start + matchLen),
+                  match: match};
+      };
+    } else { // String query
+      var origQuery = query;
+      if (caseFold) query = query.toLowerCase();
+      var fold = caseFold ? function(str){return str.toLowerCase();} : function(str){return str;};
+      var target = query.split("\n");
+      // Different methods for single-line and multi-line queries
+      if (target.length == 1) {
+        if (!query.length) {
+          // Empty string would match anything and never progress, so
+          // we define it to match nothing instead.
+          this.matches = function() {};
+        } else {
+          this.matches = function(reverse, pos) {
+            if (reverse) {
+              var orig = doc.getLine(pos.line).slice(0, pos.ch), line = fold(orig);
+              var match = line.lastIndexOf(query);
+              if (match > -1) {
+                match = adjustPos(orig, line, match);
+                return {from: Pos(pos.line, match), to: Pos(pos.line, match + origQuery.length)};
+              }
+             } else {
+               var orig = doc.getLine(pos.line).slice(pos.ch), line = fold(orig);
+               var match = line.indexOf(query);
+               if (match > -1) {
+                 match = adjustPos(orig, line, match) + pos.ch;
+                 return {from: Pos(pos.line, match), to: Pos(pos.line, match + origQuery.length)};
+               }
+            }
+          };
+        }
+      } else {
+        var origTarget = origQuery.split("\n");
+        this.matches = function(reverse, pos) {
+          var last = target.length - 1;
+          if (reverse) {
+            if (pos.line - (target.length - 1) < doc.firstLine()) return;
+            if (fold(doc.getLine(pos.line).slice(0, origTarget[last].length)) != target[target.length - 1]) return;
+            var to = Pos(pos.line, origTarget[last].length);
+            for (var ln = pos.line - 1, i = last - 1; i >= 1; --i, --ln)
+              if (target[i] != fold(doc.getLine(ln))) return;
+            var line = doc.getLine(ln), cut = line.length - origTarget[0].length;
+            if (fold(line.slice(cut)) != target[0]) return;
+            return {from: Pos(ln, cut), to: to};
+          } else {
+            if (pos.line + (target.length - 1) > doc.lastLine()) return;
+            var line = doc.getLine(pos.line), cut = line.length - origTarget[0].length;
+            if (fold(line.slice(cut)) != target[0]) return;
+            var from = Pos(pos.line, cut);
+            for (var ln = pos.line + 1, i = 1; i < last; ++i, ++ln)
+              if (target[i] != fold(doc.getLine(ln))) return;
+            if (fold(doc.getLine(ln).slice(0, origTarget[last].length)) != target[last]) return;
+            return {from: from, to: Pos(ln, origTarget[last].length)};
+          }
+        };
+      }
+    }
+  }
+
+  SearchCursor.prototype = {
+    findNext: function() {return this.find(false);},
+    findPrevious: function() {return this.find(true);},
+
+    find: function(reverse) {
+      var self = this, pos = this.doc.clipPos(reverse ? this.pos.from : this.pos.to);
+      function savePosAndFail(line) {
+        var pos = Pos(line, 0);
+        self.pos = {from: pos, to: pos};
+        self.atOccurrence = false;
+        return false;
+      }
+
+      for (;;) {
+        if (this.pos = this.matches(reverse, pos)) {
+          this.atOccurrence = true;
+          return this.pos.match || true;
+        }
+        if (reverse) {
+          if (!pos.line) return savePosAndFail(0);
+          pos = Pos(pos.line-1, this.doc.getLine(pos.line-1).length);
+        }
+        else {
+          var maxLine = this.doc.lineCount();
+          if (pos.line == maxLine - 1) return savePosAndFail(maxLine);
+          pos = Pos(pos.line + 1, 0);
+        }
+      }
+    },
+
+    from: function() {if (this.atOccurrence) return this.pos.from;},
+    to: function() {if (this.atOccurrence) return this.pos.to;},
+
+    replace: function(newText, origin) {
+      if (!this.atOccurrence) return;
+      var lines = CodeMirror.splitLines(newText);
+      this.doc.replaceRange(lines, this.pos.from, this.pos.to, origin);
+      this.pos.to = Pos(this.pos.from.line + lines.length - 1,
+                        lines[lines.length - 1].length + (lines.length == 1 ? this.pos.from.ch : 0));
+    }
+  };
+
+  // Maps a position in a case-folded line back to a position in the original line
+  // (compensating for codepoints increasing in number during folding)
+  function adjustPos(orig, folded, pos) {
+    if (orig.length == folded.length) return pos;
+    for (var pos1 = Math.min(pos, orig.length);;) {
+      var len1 = orig.slice(0, pos1).toLowerCase().length;
+      if (len1 < pos) ++pos1;
+      else if (len1 > pos) --pos1;
+      else return pos1;
+    }
+  }
+
+  CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) {
+    return new SearchCursor(this.doc, query, pos, caseFold);
+  });
+  CodeMirror.defineDocExtension("getSearchCursor", function(query, pos, caseFold) {
+    return new SearchCursor(this, query, pos, caseFold);
+  });
+
+  CodeMirror.defineExtension("selectMatches", function(query, caseFold) {
+    var ranges = [];
+    var cur = this.getSearchCursor(query, this.getCursor("from"), caseFold);
+    while (cur.findNext()) {
+      if (CodeMirror.cmpPos(cur.to(), this.getCursor("to")) > 0) break;
+      ranges.push({anchor: cur.from(), head: cur.to()});
+    }
+    if (ranges.length)
+      this.setSelections(ranges, 0);
+  });
+});
diff --git a/src/main/resources/codemirror/addon/selection/active-line.js b/src/main/resources/codemirror/addon/selection/active-line.js
new file mode 100755
index 0000000..22da2e0
--- /dev/null
+++ b/src/main/resources/codemirror/addon/selection/active-line.js
@@ -0,0 +1,71 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Because sometimes you need to style the cursor's line.
+//
+// Adds an option 'styleActiveLine' which, when enabled, gives the
+// active line's wrapping <div> the CSS class "CodeMirror-activeline",
+// and gives its background <div> the class "CodeMirror-activeline-background".
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+  var WRAP_CLASS = "CodeMirror-activeline";
+  var BACK_CLASS = "CodeMirror-activeline-background";
+
+  CodeMirror.defineOption("styleActiveLine", false, function(cm, val, old) {
+    var prev = old && old != CodeMirror.Init;
+    if (val && !prev) {
+      cm.state.activeLines = [];
+      updateActiveLines(cm, cm.listSelections());
+      cm.on("beforeSelectionChange", selectionChange);
+    } else if (!val && prev) {
+      cm.off("beforeSelectionChange", selectionChange);
+      clearActiveLines(cm);
+      delete cm.state.activeLines;
+    }
+  });
+
+  function clearActiveLines(cm) {
+    for (var i = 0; i < cm.state.activeLines.length; i++) {
+      cm.removeLineClass(cm.state.activeLines[i], "wrap", WRAP_CLASS);
+      cm.removeLineClass(cm.state.activeLines[i], "background", BACK_CLASS);
+    }
+  }
+
+  function sameArray(a, b) {
+    if (a.length != b.length) return false;
+    for (var i = 0; i < a.length; i++)
+      if (a[i] != b[i]) return false;
+    return true;
+  }
+
+  function updateActiveLines(cm, ranges) {
+    var active = [];
+    for (var i = 0; i < ranges.length; i++) {
+      var range = ranges[i];
+      if (!range.empty()) continue;
+      var line = cm.getLineHandleVisualStart(range.head.line);
+      if (active[active.length - 1] != line) active.push(line);
+    }
+    if (sameArray(cm.state.activeLines, active)) return;
+    cm.operation(function() {
+      clearActiveLines(cm);
+      for (var i = 0; i < active.length; i++) {
+        cm.addLineClass(active[i], "wrap", WRAP_CLASS);
+        cm.addLineClass(active[i], "background", BACK_CLASS);
+      }
+      cm.state.activeLines = active;
+    });
+  }
+
+  function selectionChange(cm, sel) {
+    updateActiveLines(cm, sel.ranges);
+  }
+});
diff --git a/src/main/resources/codemirror/addon/selection/mark-selection.js b/src/main/resources/codemirror/addon/selection/mark-selection.js
new file mode 100755
index 0000000..5c42d21
--- /dev/null
+++ b/src/main/resources/codemirror/addon/selection/mark-selection.js
@@ -0,0 +1,118 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Because sometimes you need to mark the selected *text*.
+//
+// Adds an option 'styleSelectedText' which, when enabled, gives
+// selected text the CSS class given as option value, or
+// "CodeMirror-selectedtext" when the value is not a string.
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineOption("styleSelectedText", false, function(cm, val, old) {
+    var prev = old && old != CodeMirror.Init;
+    if (val && !prev) {
+      cm.state.markedSelection = [];
+      cm.state.markedSelectionStyle = typeof val == "string" ? val : "CodeMirror-selectedtext";
+      reset(cm);
+      cm.on("cursorActivity", onCursorActivity);
+      cm.on("change", onChange);
+    } else if (!val && prev) {
+      cm.off("cursorActivity", onCursorActivity);
+      cm.off("change", onChange);
+      clear(cm);
+      cm.state.markedSelection = cm.state.markedSelectionStyle = null;
+    }
+  });
+
+  function onCursorActivity(cm) {
+    cm.operation(function() { update(cm); });
+  }
+
+  function onChange(cm) {
+    if (cm.state.markedSelection.length)
+      cm.operation(function() { clear(cm); });
+  }
+
+  var CHUNK_SIZE = 8;
+  var Pos = CodeMirror.Pos;
+  var cmp = CodeMirror.cmpPos;
+
+  function coverRange(cm, from, to, addAt) {
+    if (cmp(from, to) == 0) return;
+    var array = cm.state.markedSelection;
+    var cls = cm.state.markedSelectionStyle;
+    for (var line = from.line;;) {
+      var start = line == from.line ? from : Pos(line, 0);
+      var endLine = line + CHUNK_SIZE, atEnd = endLine >= to.line;
+      var end = atEnd ? to : Pos(endLine, 0);
+      var mark = cm.markText(start, end, {className: cls});
+      if (addAt == null) array.push(mark);
+      else array.splice(addAt++, 0, mark);
+      if (atEnd) break;
+      line = endLine;
+    }
+  }
+
+  function clear(cm) {
+    var array = cm.state.markedSelection;
+    for (var i = 0; i < array.length; ++i) array[i].clear();
+    array.length = 0;
+  }
+
+  function reset(cm) {
+    clear(cm);
+    var ranges = cm.listSelections();
+    for (var i = 0; i < ranges.length; i++)
+      coverRange(cm, ranges[i].from(), ranges[i].to());
+  }
+
+  function update(cm) {
+    if (!cm.somethingSelected()) return clear(cm);
+    if (cm.listSelections().length > 1) return reset(cm);
+
+    var from = cm.getCursor("start"), to = cm.getCursor("end");
+
+    var array = cm.state.markedSelection;
+    if (!array.length) return coverRange(cm, from, to);
+
+    var coverStart = array[0].find(), coverEnd = array[array.length - 1].find();
+    if (!coverStart || !coverEnd || to.line - from.line < CHUNK_SIZE ||
+        cmp(from, coverEnd.to) >= 0 || cmp(to, coverStart.from) <= 0)
+      return reset(cm);
+
+    while (cmp(from, coverStart.from) > 0) {
+      array.shift().clear();
+      coverStart = array[0].find();
+    }
+    if (cmp(from, coverStart.from) < 0) {
+      if (coverStart.to.line - from.line < CHUNK_SIZE) {
+        array.shift().clear();
+        coverRange(cm, from, coverStart.to, 0);
+      } else {
+        coverRange(cm, from, coverStart.from, 0);
+      }
+    }
+
+    while (cmp(to, coverEnd.to) < 0) {
+      array.pop().clear();
+      coverEnd = array[array.length - 1].find();
+    }
+    if (cmp(to, coverEnd.to) > 0) {
+      if (to.line - coverEnd.from.line < CHUNK_SIZE) {
+        array.pop().clear();
+        coverRange(cm, coverEnd.from, to);
+      } else {
+        coverRange(cm, coverEnd.to, to);
+      }
+    }
+  }
+});
diff --git a/src/main/resources/codemirror/addon/selection/selection-pointer.js b/src/main/resources/codemirror/addon/selection/selection-pointer.js
new file mode 100755
index 0000000..ef5e404
--- /dev/null
+++ b/src/main/resources/codemirror/addon/selection/selection-pointer.js
@@ -0,0 +1,98 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineOption("selectionPointer", false, function(cm, val) {
+    var data = cm.state.selectionPointer;
+    if (data) {
+      CodeMirror.off(cm.getWrapperElement(), "mousemove", data.mousemove);
+      CodeMirror.off(cm.getWrapperElement(), "mouseout", data.mouseout);
+      CodeMirror.off(window, "scroll", data.windowScroll);
+      cm.off("cursorActivity", reset);
+      cm.off("scroll", reset);
+      cm.state.selectionPointer = null;
+      cm.display.lineDiv.style.cursor = "";
+    }
+    if (val) {
+      data = cm.state.selectionPointer = {
+        value: typeof val == "string" ? val : "default",
+        mousemove: function(event) { mousemove(cm, event); },
+        mouseout: function(event) { mouseout(cm, event); },
+        windowScroll: function() { reset(cm); },
+        rects: null,
+        mouseX: null, mouseY: null,
+        willUpdate: false
+      };
+      CodeMirror.on(cm.getWrapperElement(), "mousemove", data.mousemove);
+      CodeMirror.on(cm.getWrapperElement(), "mouseout", data.mouseout);
+      CodeMirror.on(window, "scroll", data.windowScroll);
+      cm.on("cursorActivity", reset);
+      cm.on("scroll", reset);
+    }
+  });
+
+  function mousemove(cm, event) {
+    var data = cm.state.selectionPointer;
+    if (event.buttons == null ? event.which : event.buttons) {
+      data.mouseX = data.mouseY = null;
+    } else {
+      data.mouseX = event.clientX;
+      data.mouseY = event.clientY;
+    }
+    scheduleUpdate(cm);
+  }
+
+  function mouseout(cm, event) {
+    if (!cm.getWrapperElement().contains(event.relatedTarget)) {
+      var data = cm.state.selectionPointer;
+      data.mouseX = data.mouseY = null;
+      scheduleUpdate(cm);
+    }
+  }
+
+  function reset(cm) {
+    cm.state.selectionPointer.rects = null;
+    scheduleUpdate(cm);
+  }
+
+  function scheduleUpdate(cm) {
+    if (!cm.state.selectionPointer.willUpdate) {
+      cm.state.selectionPointer.willUpdate = true;
+      setTimeout(function() {
+        update(cm);
+        cm.state.selectionPointer.willUpdate = false;
+      }, 50);
+    }
+  }
+
+  function update(cm) {
+    var data = cm.state.selectionPointer;
+    if (!data) return;
+    if (data.rects == null && data.mouseX != null) {
+      data.rects = [];
+      if (cm.somethingSelected()) {
+        for (var sel = cm.display.selectionDiv.firstChild; sel; sel = sel.nextSibling)
+          data.rects.push(sel.getBoundingClientRect());
+      }
+    }
+    var inside = false;
+    if (data.mouseX != null) for (var i = 0; i < data.rects.length; i++) {
+      var rect = data.rects[i];
+      if (rect.left <= data.mouseX && rect.right >= data.mouseX &&
+          rect.top <= data.mouseY && rect.bottom >= data.mouseY)
+        inside = true;
+    }
+    var cursor = inside ? data.value : "";
+    if (cm.display.lineDiv.style.cursor != cursor)
+      cm.display.lineDiv.style.cursor = cursor;
+  }
+});
diff --git a/src/main/resources/codemirror/addon/tern/tern.css b/src/main/resources/codemirror/addon/tern/tern.css
new file mode 100755
index 0000000..76fba33
--- /dev/null
+++ b/src/main/resources/codemirror/addon/tern/tern.css
@@ -0,0 +1,86 @@
+.CodeMirror-Tern-completion {
+  padding-left: 22px;
+  position: relative;
+}
+.CodeMirror-Tern-completion:before {
+  position: absolute;
+  left: 2px;
+  bottom: 2px;
+  border-radius: 50%;
+  font-size: 12px;
+  font-weight: bold;
+  height: 15px;
+  width: 15px;
+  line-height: 16px;
+  text-align: center;
+  color: white;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+}
+.CodeMirror-Tern-completion-unknown:before {
+  content: "?";
+  background: #4bb;
+}
+.CodeMirror-Tern-completion-object:before {
+  content: "O";
+  background: #77c;
+}
+.CodeMirror-Tern-completion-fn:before {
+  content: "F";
+  background: #7c7;
+}
+.CodeMirror-Tern-completion-array:before {
+  content: "A";
+  background: #c66;
+}
+.CodeMirror-Tern-completion-number:before {
+  content: "1";
+  background: #999;
+}
+.CodeMirror-Tern-completion-string:before {
+  content: "S";
+  background: #999;
+}
+.CodeMirror-Tern-completion-bool:before {
+  content: "B";
+  background: #999;
+}
+
+.CodeMirror-Tern-completion-guess {
+  color: #999;
+}
+
+.CodeMirror-Tern-tooltip {
+  border: 1px solid silver;
+  border-radius: 3px;
+  color: #444;
+  padding: 2px 5px;
+  font-size: 90%;
+  font-family: monospace;
+  background-color: white;
+  white-space: pre-wrap;
+
+  max-width: 40em;
+  position: absolute;
+  z-index: 10;
+  -webkit-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+  -moz-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+  box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+
+  transition: opacity 1s;
+  -moz-transition: opacity 1s;
+  -webkit-transition: opacity 1s;
+  -o-transition: opacity 1s;
+  -ms-transition: opacity 1s;
+}
+
+.CodeMirror-Tern-hint-doc {
+  max-width: 25em;
+  margin-top: -3px;
+}
+
+.CodeMirror-Tern-fname { color: black; }
+.CodeMirror-Tern-farg { color: #70a; }
+.CodeMirror-Tern-farg-current { text-decoration: underline; }
+.CodeMirror-Tern-type { color: #07c; }
+.CodeMirror-Tern-fhint-guess { opacity: .7; }
diff --git a/src/main/resources/codemirror/addon/tern/tern.js b/src/main/resources/codemirror/addon/tern/tern.js
new file mode 100755
index 0000000..dfb19b8
--- /dev/null
+++ b/src/main/resources/codemirror/addon/tern/tern.js
@@ -0,0 +1,699 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Glue code between CodeMirror and Tern.
+//
+// Create a CodeMirror.TernServer to wrap an actual Tern server,
+// register open documents (CodeMirror.Doc instances) with it, and
+// call its methods to activate the assisting functions that Tern
+// provides.
+//
+// Options supported (all optional):
+// * defs: An array of JSON definition data structures.
+// * plugins: An object mapping plugin names to configuration
+//   options.
+// * getFile: A function(name, c) that can be used to access files in
+//   the project that haven't been loaded yet. Simply do c(null) to
+//   indicate that a file is not available.
+// * fileFilter: A function(value, docName, doc) that will be applied
+//   to documents before passing them on to Tern.
+// * switchToDoc: A function(name, doc) that should, when providing a
+//   multi-file view, switch the view or focus to the named file.
+// * showError: A function(editor, message) that can be used to
+//   override the way errors are displayed.
+// * completionTip: Customize the content in tooltips for completions.
+//   Is passed a single argument—the completion's data as returned by
+//   Tern—and may return a string, DOM node, or null to indicate that
+//   no tip should be shown. By default the docstring is shown.
+// * typeTip: Like completionTip, but for the tooltips shown for type
+//   queries.
+// * responseFilter: A function(doc, query, request, error, data) that
+//   will be applied to the Tern responses before treating them
+//
+//
+// It is possible to run the Tern server in a web worker by specifying
+// these additional options:
+// * useWorker: Set to true to enable web worker mode. You'll probably
+//   want to feature detect the actual value you use here, for example
+//   !!window.Worker.
+// * workerScript: The main script of the worker. Point this to
+//   wherever you are hosting worker.js from this directory.
+// * workerDeps: An array of paths pointing (relative to workerScript)
+//   to the Acorn and Tern libraries and any Tern plugins you want to
+//   load. Or, if you minified those into a single script and included
+//   them in the workerScript, simply leave this undefined.
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+  // declare global: tern
+
+  CodeMirror.TernServer = function(options) {
+    var self = this;
+    this.options = options || {};
+    var plugins = this.options.plugins || (this.options.plugins = {});
+    if (!plugins.doc_comment) plugins.doc_comment = true;
+    this.docs = Object.create(null);
+    if (this.options.useWorker) {
+      this.server = new WorkerServer(this);
+    } else {
+      this.server = new tern.Server({
+        getFile: function(name, c) { return getFile(self, name, c); },
+        async: true,
+        defs: this.options.defs || [],
+        plugins: plugins
+      });
+    }
+    this.trackChange = function(doc, change) { trackChange(self, doc, change); };
+
+    this.cachedArgHints = null;
+    this.activeArgHints = null;
+    this.jumpStack = [];
+
+    this.getHint = function(cm, c) { return hint(self, cm, c); };
+    this.getHint.async = true;
+  };
+
+  CodeMirror.TernServer.prototype = {
+    addDoc: function(name, doc) {
+      var data = {doc: doc, name: name, changed: null};
+      this.server.addFile(name, docValue(this, data));
+      CodeMirror.on(doc, "change", this.trackChange);
+      return this.docs[name] = data;
+    },
+
+    delDoc: function(id) {
+      var found = resolveDoc(this, id);
+      if (!found) return;
+      CodeMirror.off(found.doc, "change", this.trackChange);
+      delete this.docs[found.name];
+      this.server.delFile(found.name);
+    },
+
+    hideDoc: function(id) {
+      closeArgHints(this);
+      var found = resolveDoc(this, id);
+      if (found && found.changed) sendDoc(this, found);
+    },
+
+    complete: function(cm) {
+      cm.showHint({hint: this.getHint});
+    },
+
+    showType: function(cm, pos, c) { showContextInfo(this, cm, pos, "type", c); },
+
+    showDocs: function(cm, pos, c) { showContextInfo(this, cm, pos, "documentation", c); },
+
+    updateArgHints: function(cm) { updateArgHints(this, cm); },
+
+    jumpToDef: function(cm) { jumpToDef(this, cm); },
+
+    jumpBack: function(cm) { jumpBack(this, cm); },
+
+    rename: function(cm) { rename(this, cm); },
+
+    selectName: function(cm) { selectName(this, cm); },
+
+    request: function (cm, query, c, pos) {
+      var self = this;
+      var doc = findDoc(this, cm.getDoc());
+      var request = buildRequest(this, doc, query, pos);
+      var extraOptions = request.query && this.options.queryOptions && this.options.queryOptions[request.query.type]
+      if (extraOptions) for (var prop in extraOptions) request.query[prop] = extraOptions[prop];
+
+      this.server.request(request, function (error, data) {
+        if (!error && self.options.responseFilter)
+          data = self.options.responseFilter(doc, query, request, error, data);
+        c(error, data);
+      });
+    },
+
+    destroy: function () {
+      if (this.worker) {
+        this.worker.terminate();
+        this.worker = null;
+      }
+    }
+  };
+
+  var Pos = CodeMirror.Pos;
+  var cls = "CodeMirror-Tern-";
+  var bigDoc = 250;
+
+  function getFile(ts, name, c) {
+    var buf = ts.docs[name];
+    if (buf)
+      c(docValue(ts, buf));
+    else if (ts.options.getFile)
+      ts.options.getFile(name, c);
+    else
+      c(null);
+  }
+
+  function findDoc(ts, doc, name) {
+    for (var n in ts.docs) {
+      var cur = ts.docs[n];
+      if (cur.doc == doc) return cur;
+    }
+    if (!name) for (var i = 0;; ++i) {
+      n = "[doc" + (i || "") + "]";
+      if (!ts.docs[n]) { name = n; break; }
+    }
+    return ts.addDoc(name, doc);
+  }
+
+  function resolveDoc(ts, id) {
+    if (typeof id == "string") return ts.docs[id];
+    if (id instanceof CodeMirror) id = id.getDoc();
+    if (id instanceof CodeMirror.Doc) return findDoc(ts, id);
+  }
+
+  function trackChange(ts, doc, change) {
+    var data = findDoc(ts, doc);
+
+    var argHints = ts.cachedArgHints;
+    if (argHints && argHints.doc == doc && cmpPos(argHints.start, change.to) <= 0)
+      ts.cachedArgHints = null;
+
+    var changed = data.changed;
+    if (changed == null)
+      data.changed = changed = {from: change.from.line, to: change.from.line};
+    var end = change.from.line + (change.text.length - 1);
+    if (change.from.line < changed.to) changed.to = changed.to - (change.to.line - end);
+    if (end >= changed.to) changed.to = end + 1;
+    if (changed.from > change.from.line) changed.from = change.from.line;
+
+    if (doc.lineCount() > bigDoc && change.to - changed.from > 100) setTimeout(function() {
+      if (data.changed && data.changed.to - data.changed.from > 100) sendDoc(ts, data);
+    }, 200);
+  }
+
+  function sendDoc(ts, doc) {
+    ts.server.request({files: [{type: "full", name: doc.name, text: docValue(ts, doc)}]}, function(error) {
+      if (error) window.console.error(error);
+      else doc.changed = null;
+    });
+  }
+
+  // Completion
+
+  function hint(ts, cm, c) {
+    ts.request(cm, {type: "completions", types: true, docs: true, urls: true}, function(error, data) {
+      if (error) return showError(ts, cm, error);
+      var completions = [], after = "";
+      var from = data.start, to = data.end;
+      if (cm.getRange(Pos(from.line, from.ch - 2), from) == "[\"" &&
+          cm.getRange(to, Pos(to.line, to.ch + 2)) != "\"]")
+        after = "\"]";
+
+      for (var i = 0; i < data.completions.length; ++i) {
+        var completion = data.completions[i], className = typeToIcon(completion.type);
+        if (data.guess) className += " " + cls + "guess";
+        completions.push({text: completion.name + after,
+                          displayText: completion.name,
+                          className: className,
+                          data: completion});
+      }
+
+      var obj = {from: from, to: to, list: completions};
+      var tooltip = null;
+      CodeMirror.on(obj, "close", function() { remove(tooltip); });
+      CodeMirror.on(obj, "update", function() { remove(tooltip); });
+      CodeMirror.on(obj, "select", function(cur, node) {
+        remove(tooltip);
+        var content = ts.options.completionTip ? ts.options.completionTip(cur.data) : cur.data.doc;
+        if (content) {
+          tooltip = makeTooltip(node.parentNode.getBoundingClientRect().right + window.pageXOffset,
+                                node.getBoundingClientRect().top + window.pageYOffset, content);
+          tooltip.className += " " + cls + "hint-doc";
+        }
+      });
+      c(obj);
+    });
+  }
+
+  function typeToIcon(type) {
+    var suffix;
+    if (type == "?") suffix = "unknown";
+    else if (type == "number" || type == "string" || type == "bool") suffix = type;
+    else if (/^fn\(/.test(type)) suffix = "fn";
+    else if (/^\[/.test(type)) suffix = "array";
+    else suffix = "object";
+    return cls + "completion " + cls + "completion-" + suffix;
+  }
+
+  // Type queries
+
+  function showContextInfo(ts, cm, pos, queryName, c) {
+    ts.request(cm, queryName, function(error, data) {
+      if (error) return showError(ts, cm, error);
+      if (ts.options.typeTip) {
+        var tip = ts.options.typeTip(data);
+      } else {
+        var tip = elt("span", null, elt("strong", null, data.type || "not found"));
+        if (data.doc)
+          tip.appendChild(document.createTextNode(" — " + data.doc));
+        if (data.url) {
+          tip.appendChild(document.createTextNode(" "));
+          var child = tip.appendChild(elt("a", null, "[docs]"));
+          child.href = data.url;
+          child.target = "_blank";
+        }
+      }
+      tempTooltip(cm, tip);
+      if (c) c();
+    }, pos);
+  }
+
+  // Maintaining argument hints
+
+  function updateArgHints(ts, cm) {
+    closeArgHints(ts);
+
+    if (cm.somethingSelected()) return;
+    var state = cm.getTokenAt(cm.getCursor()).state;
+    var inner = CodeMirror.innerMode(cm.getMode(), state);
+    if (inner.mode.name != "javascript") return;
+    var lex = inner.state.lexical;
+    if (lex.info != "call") return;
+
+    var ch, argPos = lex.pos || 0, tabSize = cm.getOption("tabSize");
+    for (var line = cm.getCursor().line, e = Math.max(0, line - 9), found = false; line >= e; --line) {
+      var str = cm.getLine(line), extra = 0;
+      for (var pos = 0;;) {
+        var tab = str.indexOf("\t", pos);
+        if (tab == -1) break;
+        extra += tabSize - (tab + extra) % tabSize - 1;
+        pos = tab + 1;
+      }
+      ch = lex.column - extra;
+      if (str.charAt(ch) == "(") {found = true; break;}
+    }
+    if (!found) return;
+
+    var start = Pos(line, ch);
+    var cache = ts.cachedArgHints;
+    if (cache && cache.doc == cm.getDoc() && cmpPos(start, cache.start) == 0)
+      return showArgHints(ts, cm, argPos);
+
+    ts.request(cm, {type: "type", preferFunction: true, end: start}, function(error, data) {
+      if (error || !data.type || !(/^fn\(/).test(data.type)) return;
+      ts.cachedArgHints = {
+        start: pos,
+        type: parseFnType(data.type),
+        name: data.exprName || data.name || "fn",
+        guess: data.guess,
+        doc: cm.getDoc()
+      };
+      showArgHints(ts, cm, argPos);
+    });
+  }
+
+  function showArgHints(ts, cm, pos) {
+    closeArgHints(ts);
+
+    var cache = ts.cachedArgHints, tp = cache.type;
+    var tip = elt("span", cache.guess ? cls + "fhint-guess" : null,
+                  elt("span", cls + "fname", cache.name), "(");
+    for (var i = 0; i < tp.args.length; ++i) {
+      if (i) tip.appendChild(document.createTextNode(", "));
+      var arg = tp.args[i];
+      tip.appendChild(elt("span", cls + "farg" + (i == pos ? " " + cls + "farg-current" : ""), arg.name || "?"));
+      if (arg.type != "?") {
+        tip.appendChild(document.createTextNode(":\u00a0"));
+        tip.appendChild(elt("span", cls + "type", arg.type));
+      }
+    }
+    tip.appendChild(document.createTextNode(tp.rettype ? ") ->\u00a0" : ")"));
+    if (tp.rettype) tip.appendChild(elt("span", cls + "type", tp.rettype));
+    var place = cm.cursorCoords(null, "page");
+    ts.activeArgHints = makeTooltip(place.right + 1, place.bottom, tip);
+  }
+
+  function parseFnType(text) {
+    var args = [], pos = 3;
+
+    function skipMatching(upto) {
+      var depth = 0, start = pos;
+      for (;;) {
+        var next = text.charAt(pos);
+        if (upto.test(next) && !depth) return text.slice(start, pos);
+        if (/[{\[\(]/.test(next)) ++depth;
+        else if (/[}\]\)]/.test(next)) --depth;
+        ++pos;
+      }
+    }
+
+    // Parse arguments
+    if (text.charAt(pos) != ")") for (;;) {
+      var name = text.slice(pos).match(/^([^, \(\[\{]+): /);
+      if (name) {
+        pos += name[0].length;
+        name = name[1];
+      }
+      args.push({name: name, type: skipMatching(/[\),]/)});
+      if (text.charAt(pos) == ")") break;
+      pos += 2;
+    }
+
+    var rettype = text.slice(pos).match(/^\) -> (.*)$/);
+
+    return {args: args, rettype: rettype && rettype[1]};
+  }
+
+  // Moving to the definition of something
+
+  function jumpToDef(ts, cm) {
+    function inner(varName) {
+      var req = {type: "definition", variable: varName || null};
+      var doc = findDoc(ts, cm.getDoc());
+      ts.server.request(buildRequest(ts, doc, req), function(error, data) {
+        if (error) return showError(ts, cm, error);
+        if (!data.file && data.url) { window.open(data.url); return; }
+
+        if (data.file) {
+          var localDoc = ts.docs[data.file], found;
+          if (localDoc && (found = findContext(localDoc.doc, data))) {
+            ts.jumpStack.push({file: doc.name,
+                               start: cm.getCursor("from"),
+                               end: cm.getCursor("to")});
+            moveTo(ts, doc, localDoc, found.start, found.end);
+            return;
+          }
+        }
+        showError(ts, cm, "Could not find a definition.");
+      });
+    }
+
+    if (!atInterestingExpression(cm))
+      dialog(cm, "Jump to variable", function(name) { if (name) inner(name); });
+    else
+      inner();
+  }
+
+  function jumpBack(ts, cm) {
+    var pos = ts.jumpStack.pop(), doc = pos && ts.docs[pos.file];
+    if (!doc) return;
+    moveTo(ts, findDoc(ts, cm.getDoc()), doc, pos.start, pos.end);
+  }
+
+  function moveTo(ts, curDoc, doc, start, end) {
+    doc.doc.setSelection(start, end);
+    if (curDoc != doc && ts.options.switchToDoc) {
+      closeArgHints(ts);
+      ts.options.switchToDoc(doc.name, doc.doc);
+    }
+  }
+
+  // The {line,ch} representation of positions makes this rather awkward.
+  function findContext(doc, data) {
+    var before = data.context.slice(0, data.contextOffset).split("\n");
+    var startLine = data.start.line - (before.length - 1);
+    var start = Pos(startLine, (before.length == 1 ? data.start.ch : doc.getLine(startLine).length) - before[0].length);
+
+    var text = doc.getLine(startLine).slice(start.ch);
+    for (var cur = startLine + 1; cur < doc.lineCount() && text.length < data.context.length; ++cur)
+      text += "\n" + doc.getLine(cur);
+    if (text.slice(0, data.context.length) == data.context) return data;
+
+    var cursor = doc.getSearchCursor(data.context, 0, false);
+    var nearest, nearestDist = Infinity;
+    while (cursor.findNext()) {
+      var from = cursor.from(), dist = Math.abs(from.line - start.line) * 10000;
+      if (!dist) dist = Math.abs(from.ch - start.ch);
+      if (dist < nearestDist) { nearest = from; nearestDist = dist; }
+    }
+    if (!nearest) return null;
+
+    if (before.length == 1)
+      nearest.ch += before[0].length;
+    else
+      nearest = Pos(nearest.line + (before.length - 1), before[before.length - 1].length);
+    if (data.start.line == data.end.line)
+      var end = Pos(nearest.line, nearest.ch + (data.end.ch - data.start.ch));
+    else
+      var end = Pos(nearest.line + (data.end.line - data.start.line), data.end.ch);
+    return {start: nearest, end: end};
+  }
+
+  function atInterestingExpression(cm) {
+    var pos = cm.getCursor("end"), tok = cm.getTokenAt(pos);
+    if (tok.start < pos.ch && tok.type == "comment") return false;
+    return /[\w)\]]/.test(cm.getLine(pos.line).slice(Math.max(pos.ch - 1, 0), pos.ch + 1));
+  }
+
+  // Variable renaming
+
+  function rename(ts, cm) {
+    var token = cm.getTokenAt(cm.getCursor());
+    if (!/\w/.test(token.string)) return showError(ts, cm, "Not at a variable");
+    dialog(cm, "New name for " + token.string, function(newName) {
+      ts.request(cm, {type: "rename", newName: newName, fullDocs: true}, function(error, data) {
+        if (error) return showError(ts, cm, error);
+        applyChanges(ts, data.changes);
+      });
+    });
+  }
+
+  function selectName(ts, cm) {
+    var name = findDoc(ts, cm.doc).name;
+    ts.request(cm, {type: "refs"}, function(error, data) {
+      if (error) return showError(ts, cm, error);
+      var ranges = [], cur = 0;
+      for (var i = 0; i < data.refs.length; i++) {
+        var ref = data.refs[i];
+        if (ref.file == name) {
+          ranges.push({anchor: ref.start, head: ref.end});
+          if (cmpPos(cur, ref.start) >= 0 && cmpPos(cur, ref.end) <= 0)
+            cur = ranges.length - 1;
+        }
+      }
+      cm.setSelections(ranges, cur);
+    });
+  }
+
+  var nextChangeOrig = 0;
+  function applyChanges(ts, changes) {
+    var perFile = Object.create(null);
+    for (var i = 0; i < changes.length; ++i) {
+      var ch = changes[i];
+      (perFile[ch.file] || (perFile[ch.file] = [])).push(ch);
+    }
+    for (var file in perFile) {
+      var known = ts.docs[file], chs = perFile[file];;
+      if (!known) continue;
+      chs.sort(function(a, b) { return cmpPos(b.start, a.start); });
+      var origin = "*rename" + (++nextChangeOrig);
+      for (var i = 0; i < chs.length; ++i) {
+        var ch = chs[i];
+        known.doc.replaceRange(ch.text, ch.start, ch.end, origin);
+      }
+    }
+  }
+
+  // Generic request-building helper
+
+  function buildRequest(ts, doc, query, pos) {
+    var files = [], offsetLines = 0, allowFragments = !query.fullDocs;
+    if (!allowFragments) delete query.fullDocs;
+    if (typeof query == "string") query = {type: query};
+    query.lineCharPositions = true;
+    if (query.end == null) {
+      query.end = pos || doc.doc.getCursor("end");
+      if (doc.doc.somethingSelected())
+        query.start = doc.doc.getCursor("start");
+    }
+    var startPos = query.start || query.end;
+
+    if (doc.changed) {
+      if (doc.doc.lineCount() > bigDoc && allowFragments !== false &&
+          doc.changed.to - doc.changed.from < 100 &&
+          doc.changed.from <= startPos.line && doc.changed.to > query.end.line) {
+        files.push(getFragmentAround(doc, startPos, query.end));
+        query.file = "#0";
+        var offsetLines = files[0].offsetLines;
+        if (query.start != null) query.start = Pos(query.start.line - -offsetLines, query.start.ch);
+        query.end = Pos(query.end.line - offsetLines, query.end.ch);
+      } else {
+        files.push({type: "full",
+                    name: doc.name,
+                    text: docValue(ts, doc)});
+        query.file = doc.name;
+        doc.changed = null;
+      }
+    } else {
+      query.file = doc.name;
+    }
+    for (var name in ts.docs) {
+      var cur = ts.docs[name];
+      if (cur.changed && cur != doc) {
+        files.push({type: "full", name: cur.name, text: docValue(ts, cur)});
+        cur.changed = null;
+      }
+    }
+
+    return {query: query, files: files};
+  }
+
+  function getFragmentAround(data, start, end) {
+    var doc = data.doc;
+    var minIndent = null, minLine = null, endLine, tabSize = 4;
+    for (var p = start.line - 1, min = Math.max(0, p - 50); p >= min; --p) {
+      var line = doc.getLine(p), fn = line.search(/\bfunction\b/);
+      if (fn < 0) continue;
+      var indent = CodeMirror.countColumn(line, null, tabSize);
+      if (minIndent != null && minIndent <= indent) continue;
+      minIndent = indent;
+      minLine = p;
+    }
+    if (minLine == null) minLine = min;
+    var max = Math.min(doc.lastLine(), end.line + 20);
+    if (minIndent == null || minIndent == CodeMirror.countColumn(doc.getLine(start.line), null, tabSize))
+      endLine = max;
+    else for (endLine = end.line + 1; endLine < max; ++endLine) {
+      var indent = CodeMirror.countColumn(doc.getLine(endLine), null, tabSize);
+      if (indent <= minIndent) break;
+    }
+    var from = Pos(minLine, 0);
+
+    return {type: "part",
+            name: data.name,
+            offsetLines: from.line,
+            text: doc.getRange(from, Pos(endLine, 0))};
+  }
+
+  // Generic utilities
+
+  var cmpPos = CodeMirror.cmpPos;
+
+  function elt(tagname, cls /*, ... elts*/) {
+    var e = document.createElement(tagname);
+    if (cls) e.className = cls;
+    for (var i = 2; i < arguments.length; ++i) {
+      var elt = arguments[i];
+      if (typeof elt == "string") elt = document.createTextNode(elt);
+      e.appendChild(elt);
+    }
+    return e;
+  }
+
+  function dialog(cm, text, f) {
+    if (cm.openDialog)
+      cm.openDialog(text + ": <input type=text>", f);
+    else
+      f(prompt(text, ""));
+  }
+
+  // Tooltips
+
+  function tempTooltip(cm, content) {
+    if (cm.state.ternTooltip) remove(cm.state.ternTooltip);
+    var where = cm.cursorCoords();
+    var tip = cm.state.ternTooltip = makeTooltip(where.right + 1, where.bottom, content);
+    function maybeClear() {
+      old = true;
+      if (!mouseOnTip) clear();
+    }
+    function clear() {
+      cm.state.ternTooltip = null;
+      if (!tip.parentNode) return;
+      cm.off("cursorActivity", clear);
+      cm.off('blur', clear);
+      cm.off('scroll', clear);
+      fadeOut(tip);
+    }
+    var mouseOnTip = false, old = false;
+    CodeMirror.on(tip, "mousemove", function() { mouseOnTip = true; });
+    CodeMirror.on(tip, "mouseout", function(e) {
+      if (!CodeMirror.contains(tip, e.relatedTarget || e.toElement)) {
+        if (old) clear();
+        else mouseOnTip = false;
+      }
+    });
+    setTimeout(maybeClear, 1700);
+    cm.on("cursorActivity", clear);
+    cm.on('blur', clear);
+    cm.on('scroll', clear);
+  }
+
+  function makeTooltip(x, y, content) {
+    var node = elt("div", cls + "tooltip", content);
+    node.style.left = x + "px";
+    node.style.top = y + "px";
+    document.body.appendChild(node);
+    return node;
+  }
+
+  function remove(node) {
+    var p = node && node.parentNode;
+    if (p) p.removeChild(node);
+  }
+
+  function fadeOut(tooltip) {
+    tooltip.style.opacity = "0";
+    setTimeout(function() { remove(tooltip); }, 1100);
+  }
+
+  function showError(ts, cm, msg) {
+    if (ts.options.showError)
+      ts.options.showError(cm, msg);
+    else
+      tempTooltip(cm, String(msg));
+  }
+
+  function closeArgHints(ts) {
+    if (ts.activeArgHints) { remove(ts.activeArgHints); ts.activeArgHints = null; }
+  }
+
+  function docValue(ts, doc) {
+    var val = doc.doc.getValue();
+    if (ts.options.fileFilter) val = ts.options.fileFilter(val, doc.name, doc.doc);
+    return val;
+  }
+
+  // Worker wrapper
+
+  function WorkerServer(ts) {
+    var worker = ts.worker = new Worker(ts.options.workerScript);
+    worker.postMessage({type: "init",
+                        defs: ts.options.defs,
+                        plugins: ts.options.plugins,
+                        scripts: ts.options.workerDeps});
+    var msgId = 0, pending = {};
+
+    function send(data, c) {
+      if (c) {
+        data.id = ++msgId;
+        pending[msgId] = c;
+      }
+      worker.postMessage(data);
+    }
+    worker.onmessage = function(e) {
+      var data = e.data;
+      if (data.type == "getFile") {
+        getFile(ts, data.name, function(err, text) {
+          send({type: "getFile", err: String(err), text: text, id: data.id});
+        });
+      } else if (data.type == "debug") {
+        window.console.log(data.message);
+      } else if (data.id && pending[data.id]) {
+        pending[data.id](data.err, data.body);
+        delete pending[data.id];
+      }
+    };
+    worker.onerror = function(e) {
+      for (var id in pending) pending[id](e);
+      pending = {};
+    };
+
+    this.addFile = function(name, text) { send({type: "add", name: name, text: text}); };
+    this.delFile = function(name) { send({type: "del", name: name}); };
+    this.request = function(body, c) { send({type: "req", body: body}, c); };
+  }
+});
diff --git a/src/main/resources/codemirror/addon/tern/worker.js b/src/main/resources/codemirror/addon/tern/worker.js
new file mode 100755
index 0000000..887f906
--- /dev/null
+++ b/src/main/resources/codemirror/addon/tern/worker.js
@@ -0,0 +1,44 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// declare global: tern, server
+
+var server;
+
+this.onmessage = function(e) {
+  var data = e.data;
+  switch (data.type) {
+  case "init": return startServer(data.defs, data.plugins, data.scripts);
+  case "add": return server.addFile(data.name, data.text);
+  case "del": return server.delFile(data.name);
+  case "req": return server.request(data.body, function(err, reqData) {
+    postMessage({id: data.id, body: reqData, err: err && String(err)});
+  });
+  case "getFile":
+    var c = pending[data.id];
+    delete pending[data.id];
+    return c(data.err, data.text);
+  default: throw new Error("Unknown message type: " + data.type);
+  }
+};
+
+var nextId = 0, pending = {};
+function getFile(file, c) {
+  postMessage({type: "getFile", name: file, id: ++nextId});
+  pending[nextId] = c;
+}
+
+function startServer(defs, plugins, scripts) {
+  if (scripts) importScripts.apply(null, scripts);
+
+  server = new tern.Server({
+    getFile: getFile,
+    async: true,
+    defs: defs,
+    plugins: plugins
+  });
+}
+
+this.console = {
+  log: function(v) { postMessage({type: "debug", message: v}); }
+};
diff --git a/src/main/resources/codemirror/addon/wrap/hardwrap.js b/src/main/resources/codemirror/addon/wrap/hardwrap.js
new file mode 100755
index 0000000..fe9b4dd
--- /dev/null
+++ b/src/main/resources/codemirror/addon/wrap/hardwrap.js
@@ -0,0 +1,139 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var Pos = CodeMirror.Pos;
+
+  function findParagraph(cm, pos, options) {
+    var startRE = options.paragraphStart || cm.getHelper(pos, "paragraphStart");
+    for (var start = pos.line, first = cm.firstLine(); start > first; --start) {
+      var line = cm.getLine(start);
+      if (startRE && startRE.test(line)) break;
+      if (!/\S/.test(line)) { ++start; break; }
+    }
+    var endRE = options.paragraphEnd || cm.getHelper(pos, "paragraphEnd");
+    for (var end = pos.line + 1, last = cm.lastLine(); end <= last; ++end) {
+      var line = cm.getLine(end);
+      if (endRE && endRE.test(line)) { ++end; break; }
+      if (!/\S/.test(line)) break;
+    }
+    return {from: start, to: end};
+  }
+
+  function findBreakPoint(text, column, wrapOn, killTrailingSpace) {
+    for (var at = column; at > 0; --at)
+      if (wrapOn.test(text.slice(at - 1, at + 1))) break;
+    if (at == 0) at = column;
+    var endOfText = at;
+    if (killTrailingSpace)
+      while (text.charAt(endOfText - 1) == " ") --endOfText;
+    return {from: endOfText, to: at};
+  }
+
+  function wrapRange(cm, from, to, options) {
+    from = cm.clipPos(from); to = cm.clipPos(to);
+    var column = options.column || 80;
+    var wrapOn = options.wrapOn || /\s\S|-[^\.\d]/;
+    var killTrailing = options.killTrailingSpace !== false;
+    var changes = [], curLine = "", curNo = from.line;
+    var lines = cm.getRange(from, to, false);
+    if (!lines.length) return null;
+    var leadingSpace = lines[0].match(/^[ \t]*/)[0];
+
+    for (var i = 0; i < lines.length; ++i) {
+      var text = lines[i], oldLen = curLine.length, spaceInserted = 0;
+      if (curLine && text && !wrapOn.test(curLine.charAt(curLine.length - 1) + text.charAt(0))) {
+        curLine += " ";
+        spaceInserted = 1;
+      }
+      var spaceTrimmed = "";
+      if (i) {
+        spaceTrimmed = text.match(/^\s*/)[0];
+        text = text.slice(spaceTrimmed.length);
+      }
+      curLine += text;
+      if (i) {
+        var firstBreak = curLine.length > column && leadingSpace == spaceTrimmed &&
+          findBreakPoint(curLine, column, wrapOn, killTrailing);
+        // If this isn't broken, or is broken at a different point, remove old break
+        if (!firstBreak || firstBreak.from != oldLen || firstBreak.to != oldLen + spaceInserted) {
+          changes.push({text: [spaceInserted ? " " : ""],
+                        from: Pos(curNo, oldLen),
+                        to: Pos(curNo + 1, spaceTrimmed.length)});
+        } else {
+          curLine = leadingSpace + text;
+          ++curNo;
+        }
+      }
+      while (curLine.length > column) {
+        var bp = findBreakPoint(curLine, column, wrapOn, killTrailing);
+        changes.push({text: ["", leadingSpace],
+                      from: Pos(curNo, bp.from),
+                      to: Pos(curNo, bp.to)});
+        curLine = leadingSpace + curLine.slice(bp.to);
+        ++curNo;
+      }
+    }
+    if (changes.length) cm.operation(function() {
+      for (var i = 0; i < changes.length; ++i) {
+        var change = changes[i];
+        cm.replaceRange(change.text, change.from, change.to);
+      }
+    });
+    return changes.length ? {from: changes[0].from, to: CodeMirror.changeEnd(changes[changes.length - 1])} : null;
+  }
+
+  CodeMirror.defineExtension("wrapParagraph", function(pos, options) {
+    options = options || {};
+    if (!pos) pos = this.getCursor();
+    var para = findParagraph(this, pos, options);
+    return wrapRange(this, Pos(para.from, 0), Pos(para.to - 1), options);
+  });
+
+  CodeMirror.commands.wrapLines = function(cm) {
+    cm.operation(function() {
+      var ranges = cm.listSelections(), at = cm.lastLine() + 1;
+      for (var i = ranges.length - 1; i >= 0; i--) {
+        var range = ranges[i], span;
+        if (range.empty()) {
+          var para = findParagraph(cm, range.head, {});
+          span = {from: Pos(para.from, 0), to: Pos(para.to - 1)};
+        } else {
+          span = {from: range.from(), to: range.to()};
+        }
+        if (span.to.line >= at) continue;
+        at = span.from.line;
+        wrapRange(cm, span.from, span.to, {});
+      }
+    });
+  };
+
+  CodeMirror.defineExtension("wrapRange", function(from, to, options) {
+    return wrapRange(this, from, to, options || {});
+  });
+
+  CodeMirror.defineExtension("wrapParagraphsInRange", function(from, to, options) {
+    options = options || {};
+    var cm = this, paras = [];
+    for (var line = from.line; line <= to.line;) {
+      var para = findParagraph(cm, Pos(line, 0), options);
+      paras.push(para);
+      line = para.to;
+    }
+    var madeChange = false;
+    if (paras.length) cm.operation(function() {
+      for (var i = paras.length - 1; i >= 0; --i)
+        madeChange = madeChange || wrapRange(cm, Pos(paras[i].from, 0), Pos(paras[i].to - 1), options);
+    });
+    return madeChange;
+  });
+});
diff --git a/src/main/resources/codemirror/editor.html b/src/main/resources/codemirror/editor.html
new file mode 100644
index 0000000..bbd763c
--- /dev/null
+++ b/src/main/resources/codemirror/editor.html
@@ -0,0 +1,19 @@
+<html>
+    <head>
+        <title>Jace IDE</title>
+        <script src="lib/codemirror.js"></script>
+        <link rel="stylesheet" href="lib/codemirror.css"/>
+    </head>
+    <body>
+        <style type="text/css">
+            .CodeMirror {
+                border: 1px solid #eee;
+                height: auto;
+            }
+            body {
+                overflow-x: hidden;
+                overflow-y: hidden;
+            }
+        </style>
+    </body>
+</html>
\ No newline at end of file
diff --git a/src/main/resources/codemirror/lib/codemirror.css b/src/main/resources/codemirror/lib/codemirror.css
new file mode 100755
index 0000000..c4aa3c0
--- /dev/null
+++ b/src/main/resources/codemirror/lib/codemirror.css
@@ -0,0 +1,325 @@
+/* BASICS */
+
+.CodeMirror {
+  /* Set height, width, borders, and global font properties here */
+  font-family: monospace;
+  height: 300px;
+  color: black;
+}
+
+/* PADDING */
+
+.CodeMirror-lines {
+  padding: 4px 0; /* Vertical padding around content */
+}
+.CodeMirror pre {
+  padding: 0 4px; /* Horizontal padding of content */
+}
+
+.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
+  background-color: white; /* The little square between H and V scrollbars */
+}
+
+/* GUTTER */
+
+.CodeMirror-gutters {
+  border-right: 1px solid #ddd;
+  background-color: #f7f7f7;
+  white-space: nowrap;
+}
+.CodeMirror-linenumbers {}
+.CodeMirror-linenumber {
+  padding: 0 3px 0 5px;
+  min-width: 20px;
+  text-align: right;
+  color: #999;
+  white-space: nowrap;
+}
+
+.CodeMirror-guttermarker { color: black; }
+.CodeMirror-guttermarker-subtle { color: #999; }
+
+/* CURSOR */
+
+.CodeMirror div.CodeMirror-cursor {
+  border-left: 1px solid black;
+}
+/* Shown when moving in bi-directional text */
+.CodeMirror div.CodeMirror-secondarycursor {
+  border-left: 1px solid silver;
+}
+.CodeMirror.cm-fat-cursor div.CodeMirror-cursor {
+  width: auto;
+  border: 0;
+  background: #7e7;
+}
+.CodeMirror.cm-fat-cursor div.CodeMirror-cursors {
+  z-index: 1;
+}
+
+.cm-animate-fat-cursor {
+  width: auto;
+  border: 0;
+  -webkit-animation: blink 1.06s steps(1) infinite;
+  -moz-animation: blink 1.06s steps(1) infinite;
+  animation: blink 1.06s steps(1) infinite;
+}
+@-moz-keyframes blink {
+  0% { background: #7e7; }
+  50% { background: none; }
+  100% { background: #7e7; }
+}
+@-webkit-keyframes blink {
+  0% { background: #7e7; }
+  50% { background: none; }
+  100% { background: #7e7; }
+}
+@keyframes blink {
+  0% { background: #7e7; }
+  50% { background: none; }
+  100% { background: #7e7; }
+}
+
+/* Can style cursor different in overwrite (non-insert) mode */
+div.CodeMirror-overwrite div.CodeMirror-cursor {}
+
+.cm-tab { display: inline-block; text-decoration: inherit; }
+
+.CodeMirror-ruler {
+  border-left: 1px solid #ccc;
+  position: absolute;
+}
+
+/* DEFAULT THEME */
+
+.cm-s-default .cm-header {color: blue;}
+.cm-s-default .cm-quote {color: #090;}
+.cm-negative {color: #d44;}
+.cm-positive {color: #292;}
+.cm-header, .cm-strong {font-weight: bold;}
+.cm-em {font-style: italic;}
+.cm-link {text-decoration: underline;}
+.cm-strikethrough {text-decoration: line-through;}
+
+.cm-s-default .cm-keyword {color: #708;}
+.cm-s-default .cm-atom {color: #219;}
+.cm-s-default .cm-number {color: #164;}
+.cm-s-default .cm-def {color: #00f;}
+.cm-s-default .cm-variable,
+.cm-s-default .cm-punctuation,
+.cm-s-default .cm-property,
+.cm-s-default .cm-operator {}
+.cm-s-default .cm-variable-2 {color: #05a;}
+.cm-s-default .cm-variable-3 {color: #085;}
+.cm-s-default .cm-comment {color: #a50;}
+.cm-s-default .cm-string {color: #a11;}
+.cm-s-default .cm-string-2 {color: #f50;}
+.cm-s-default .cm-meta {color: #555;}
+.cm-s-default .cm-qualifier {color: #555;}
+.cm-s-default .cm-builtin {color: #30a;}
+.cm-s-default .cm-bracket {color: #997;}
+.cm-s-default .cm-tag {color: #170;}
+.cm-s-default .cm-attribute {color: #00c;}
+.cm-s-default .cm-hr {color: #999;}
+.cm-s-default .cm-link {color: #00c;}
+
+.cm-s-default .cm-error {color: #f00;}
+.cm-invalidchar {color: #f00;}
+
+.CodeMirror-composing { border-bottom: 2px solid; }
+
+/* Default styles for common addons */
+
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
+.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }
+.CodeMirror-activeline-background {background: #e8f2ff;}
+
+/* STOP */
+
+/* The rest of this file contains styles related to the mechanics of
+   the editor. You probably shouldn't touch them. */
+
+.CodeMirror {
+  position: relative;
+  overflow: hidden;
+  background: white;
+}
+
+.CodeMirror-scroll {
+  overflow: scroll !important; /* Things will break if this is overridden */
+  /* 30px is the magic margin used to hide the element's real scrollbars */
+  /* See overflow: hidden in .CodeMirror */
+  margin-bottom: -30px; margin-right: -30px;
+  padding-bottom: 30px;
+  height: 100%;
+  outline: none; /* Prevent dragging from highlighting the element */
+  position: relative;
+}
+.CodeMirror-sizer {
+  position: relative;
+  border-right: 30px solid transparent;
+}
+
+/* The fake, visible scrollbars. Used to force redraw during scrolling
+   before actuall scrolling happens, thus preventing shaking and
+   flickering artifacts. */
+.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
+  position: absolute;
+  z-index: 6;
+  display: none;
+}
+.CodeMirror-vscrollbar {
+  right: 0; top: 0;
+  overflow-x: hidden;
+  overflow-y: scroll;
+}
+.CodeMirror-hscrollbar {
+  bottom: 0; left: 0;
+  overflow-y: hidden;
+  overflow-x: scroll;
+}
+.CodeMirror-scrollbar-filler {
+  right: 0; bottom: 0;
+}
+.CodeMirror-gutter-filler {
+  left: 0; bottom: 0;
+}
+
+.CodeMirror-gutters {
+  position: absolute; left: 0; top: 0;
+  z-index: 3;
+}
+.CodeMirror-gutter {
+  white-space: normal;
+  height: 100%;
+  display: inline-block;
+  margin-bottom: -30px;
+  /* Hack to make IE7 behave */
+  *zoom:1;
+  *display:inline;
+}
+.CodeMirror-gutter-wrapper {
+  position: absolute;
+  z-index: 4;
+  height: 100%;
+}
+.CodeMirror-gutter-elt {
+  position: absolute;
+  cursor: default;
+  z-index: 4;
+}
+.CodeMirror-gutter-wrapper {
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  user-select: none;
+}
+
+.CodeMirror-lines {
+  cursor: text;
+  min-height: 1px; /* prevents collapsing before first draw */
+}
+.CodeMirror pre {
+  /* Reset some styles that the rest of the page might have set */
+  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
+  border-width: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: inherit;
+  margin: 0;
+  white-space: pre;
+  word-wrap: normal;
+  line-height: inherit;
+  color: inherit;
+  z-index: 2;
+  position: relative;
+  overflow: visible;
+  -webkit-tap-highlight-color: transparent;
+}
+.CodeMirror-wrap pre {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  word-break: normal;
+}
+
+.CodeMirror-linebackground {
+  position: absolute;
+  left: 0; right: 0; top: 0; bottom: 0;
+  z-index: 0;
+}
+
+.CodeMirror-linewidget {
+  position: relative;
+  z-index: 2;
+  overflow: auto;
+}
+
+.CodeMirror-widget {}
+
+.CodeMirror-code {
+  outline: none;
+}
+
+/* Force content-box sizing for the elements where we expect it */
+.CodeMirror-scroll,
+.CodeMirror-sizer,
+.CodeMirror-gutter,
+.CodeMirror-gutters,
+.CodeMirror-linenumber {
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+
+.CodeMirror-measure {
+  position: absolute;
+  width: 100%;
+  height: 0;
+  overflow: hidden;
+  visibility: hidden;
+}
+.CodeMirror-measure pre { position: static; }
+
+.CodeMirror div.CodeMirror-cursor {
+  position: absolute;
+  border-right: none;
+  width: 0;
+}
+
+div.CodeMirror-cursors {
+  visibility: hidden;
+  position: relative;
+  z-index: 3;
+}
+.CodeMirror-focused div.CodeMirror-cursors {
+  visibility: visible;
+}
+
+.CodeMirror-selected { background: #d9d9d9; }
+.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
+.CodeMirror-crosshair { cursor: crosshair; }
+.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }
+.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }
+
+.cm-searching {
+  background: #ffa;
+  background: rgba(255, 255, 0, .4);
+}
+
+/* IE7 hack to prevent it from returning funny offsetTops on the spans */
+.CodeMirror span { *vertical-align: text-bottom; }
+
+/* Used to force a border model for a node */
+.cm-force-border { padding-right: .1px; }
+
+@media print {
+  /* Hide the cursor when printing */
+  .CodeMirror div.CodeMirror-cursors {
+    visibility: hidden;
+  }
+}
+
+/* See issue #2901 */
+.cm-tab-wrap-hack:after { content: ''; }
+
+/* Help users use markselection to safely style text background */
+span.CodeMirror-selectedtext { background: none; }
diff --git a/src/main/resources/codemirror/lib/codemirror.js b/src/main/resources/codemirror/lib/codemirror.js
new file mode 100755
index 0000000..572cbbc
--- /dev/null
+++ b/src/main/resources/codemirror/lib/codemirror.js
@@ -0,0 +1,8735 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// This is CodeMirror (http://codemirror.net), a code editor
+// implemented in JavaScript on top of the browser's DOM.
+//
+// You can find some technical background for some of the code below
+// at http://marijnhaverbeke.nl/blog/#cm-internals .
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    module.exports = mod();
+  else if (typeof define == "function" && define.amd) // AMD
+    return define([], mod);
+  else // Plain browser env
+    this.CodeMirror = mod();
+})(function() {
+  "use strict";
+
+  // BROWSER SNIFFING
+
+  // Kludges for bugs and behavior differences that can't be feature
+  // detected are enabled based on userAgent etc sniffing.
+
+  var gecko = /gecko\/\d/i.test(navigator.userAgent);
+  var ie_upto10 = /MSIE \d/.test(navigator.userAgent);
+  var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent);
+  var ie = ie_upto10 || ie_11up;
+  var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : ie_11up[1]);
+  var webkit = /WebKit\//.test(navigator.userAgent);
+  var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(navigator.userAgent);
+  var chrome = /Chrome\//.test(navigator.userAgent);
+  var presto = /Opera\//.test(navigator.userAgent);
+  var safari = /Apple Computer/.test(navigator.vendor);
+  var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(navigator.userAgent);
+  var phantom = /PhantomJS/.test(navigator.userAgent);
+
+  var ios = /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent);
+  // This is woefully incomplete. Suggestions for alternative methods welcome.
+  var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(navigator.userAgent);
+  var mac = ios || /Mac/.test(navigator.platform);
+  var windows = /win/i.test(navigator.platform);
+
+  var presto_version = presto && navigator.userAgent.match(/Version\/(\d*\.\d*)/);
+  if (presto_version) presto_version = Number(presto_version[1]);
+  if (presto_version && presto_version >= 15) { presto = false; webkit = true; }
+  // Some browsers use the wrong event properties to signal cmd/ctrl on OS X
+  var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11));
+  var captureRightClick = gecko || (ie && ie_version >= 9);
+
+  // Optimize some code when these features are not used.
+  var sawReadOnlySpans = false, sawCollapsedSpans = false;
+
+  // EDITOR CONSTRUCTOR
+
+  // A CodeMirror instance represents an editor. This is the object
+  // that user code is usually dealing with.
+
+  function CodeMirror(place, options) {
+    if (!(this instanceof CodeMirror)) return new CodeMirror(place, options);
+
+    this.options = options = options ? copyObj(options) : {};
+    // Determine effective options based on given values and defaults.
+    copyObj(defaults, options, false);
+    setGuttersForLineNumbers(options);
+
+    var doc = options.value;
+    if (typeof doc == "string") doc = new Doc(doc, options.mode);
+    this.doc = doc;
+
+    var input = new CodeMirror.inputStyles[options.inputStyle](this);
+    var display = this.display = new Display(place, doc, input);
+    display.wrapper.CodeMirror = this;
+    updateGutters(this);
+    themeChanged(this);
+    if (options.lineWrapping)
+      this.display.wrapper.className += " CodeMirror-wrap";
+    if (options.autofocus && !mobile) display.input.focus();
+    initScrollbars(this);
+
+    this.state = {
+      keyMaps: [],  // stores maps added by addKeyMap
+      overlays: [], // highlighting overlays, as added by addOverlay
+      modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info
+      overwrite: false,
+      delayingBlurEvent: false,
+      focused: false,
+      suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
+      pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll
+      draggingText: false,
+      highlight: new Delayed(), // stores highlight worker timeout
+      keySeq: null,  // Unfinished key sequence
+      specialChars: null
+    };
+
+    var cm = this;
+
+    // Override magic textarea content restore that IE sometimes does
+    // on our hidden textarea on reload
+    if (ie && ie_version < 11) setTimeout(function() { cm.display.input.reset(true); }, 20);
+
+    registerEventHandlers(this);
+    ensureGlobalHandlers();
+
+    startOperation(this);
+    this.curOp.forceUpdate = true;
+    attachDoc(this, doc);
+
+    if ((options.autofocus && !mobile) || cm.hasFocus())
+      setTimeout(bind(onFocus, this), 20);
+    else
+      onBlur(this);
+
+    for (var opt in optionHandlers) if (optionHandlers.hasOwnProperty(opt))
+      optionHandlers[opt](this, options[opt], Init);
+    maybeUpdateLineNumberWidth(this);
+    if (options.finishInit) options.finishInit(this);
+    for (var i = 0; i < initHooks.length; ++i) initHooks[i](this);
+    endOperation(this);
+    // Suppress optimizelegibility in Webkit, since it breaks text
+    // measuring on line wrapping boundaries.
+    if (webkit && options.lineWrapping &&
+        getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
+      display.lineDiv.style.textRendering = "auto";
+  }
+
+  // DISPLAY CONSTRUCTOR
+
+  // The display handles the DOM integration, both for input reading
+  // and content drawing. It holds references to DOM nodes and
+  // display-related state.
+
+  function Display(place, doc, input) {
+    var d = this;
+    this.input = input;
+
+    // Covers bottom-right square when both scrollbars are present.
+    d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler");
+    d.scrollbarFiller.setAttribute("cm-not-content", "true");
+    // Covers bottom of gutter when coverGutterNextToScrollbar is on
+    // and h scrollbar is present.
+    d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler");
+    d.gutterFiller.setAttribute("cm-not-content", "true");
+    // Will contain the actual code, positioned to cover the viewport.
+    d.lineDiv = elt("div", null, "CodeMirror-code");
+    // Elements are added to these to represent selection and cursors.
+    d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1");
+    d.cursorDiv = elt("div", null, "CodeMirror-cursors");
+    // A visibility: hidden element used to find the size of things.
+    d.measure = elt("div", null, "CodeMirror-measure");
+    // When lines outside of the viewport are measured, they are drawn in this.
+    d.lineMeasure = elt("div", null, "CodeMirror-measure");
+    // Wraps everything that needs to exist inside the vertically-padded coordinate system
+    d.lineSpace = elt("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],
+                      null, "position: relative; outline: none");
+    // Moved around its parent to cover visible view.
+    d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-lines")], null, "position: relative");
+    // Set to the height of the document, allowing scrolling.
+    d.sizer = elt("div", [d.mover], "CodeMirror-sizer");
+    d.sizerWidth = null;
+    // Behavior of elts with overflow: auto and padding is
+    // inconsistent across browsers. This is used to ensure the
+    // scrollable area is big enough.
+    d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;");
+    // Will contain the gutters, if any.
+    d.gutters = elt("div", null, "CodeMirror-gutters");
+    d.lineGutter = null;
+    // Actual scrollable element.
+    d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll");
+    d.scroller.setAttribute("tabIndex", "-1");
+    // The element in which the editor lives.
+    d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror");
+
+    // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)
+    if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }
+    if (!webkit && !(gecko && mobile)) d.scroller.draggable = true;
+
+    if (place) {
+      if (place.appendChild) place.appendChild(d.wrapper);
+      else place(d.wrapper);
+    }
+
+    // Current rendered range (may be bigger than the view window).
+    d.viewFrom = d.viewTo = doc.first;
+    d.reportedViewFrom = d.reportedViewTo = doc.first;
+    // Information about the rendered lines.
+    d.view = [];
+    d.renderedView = null;
+    // Holds info about a single rendered line when it was rendered
+    // for measurement, while not in view.
+    d.externalMeasured = null;
+    // Empty space (in pixels) above the view
+    d.viewOffset = 0;
+    d.lastWrapHeight = d.lastWrapWidth = 0;
+    d.updateLineNumbers = null;
+
+    d.nativeBarWidth = d.barHeight = d.barWidth = 0;
+    d.scrollbarsClipped = false;
+
+    // Used to only resize the line number gutter when necessary (when
+    // the amount of lines crosses a boundary that makes its width change)
+    d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;
+    // Set to true when a non-horizontal-scrolling line widget is
+    // added. As an optimization, line widget aligning is skipped when
+    // this is false.
+    d.alignWidgets = false;
+
+    d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
+
+    // Tracks the maximum line length so that the horizontal scrollbar
+    // can be kept static when scrolling.
+    d.maxLine = null;
+    d.maxLineLength = 0;
+    d.maxLineChanged = false;
+
+    // Used for measuring wheel scrolling granularity
+    d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null;
+
+    // True when shift is held down.
+    d.shift = false;
+
+    // Used to track whether anything happened since the context menu
+    // was opened.
+    d.selForContextMenu = null;
+
+    d.activeTouch = null;
+
+    input.init(d);
+  }
+
+  // STATE UPDATES
+
+  // Used to get the editor into a consistent state again when options change.
+
+  function loadMode(cm) {
+    cm.doc.mode = CodeMirror.getMode(cm.options, cm.doc.modeOption);
+    resetModeState(cm);
+  }
+
+  function resetModeState(cm) {
+    cm.doc.iter(function(line) {
+      if (line.stateAfter) line.stateAfter = null;
+      if (line.styles) line.styles = null;
+    });
+    cm.doc.frontier = cm.doc.first;
+    startWorker(cm, 100);
+    cm.state.modeGen++;
+    if (cm.curOp) regChange(cm);
+  }
+
+  function wrappingChanged(cm) {
+    if (cm.options.lineWrapping) {
+      addClass(cm.display.wrapper, "CodeMirror-wrap");
+      cm.display.sizer.style.minWidth = "";
+      cm.display.sizerWidth = null;
+    } else {
+      rmClass(cm.display.wrapper, "CodeMirror-wrap");
+      findMaxLine(cm);
+    }
+    estimateLineHeights(cm);
+    regChange(cm);
+    clearCaches(cm);
+    setTimeout(function(){updateScrollbars(cm);}, 100);
+  }
+
+  // Returns a function that estimates the height of a line, to use as
+  // first approximation until the line becomes visible (and is thus
+  // properly measurable).
+  function estimateHeight(cm) {
+    var th = textHeight(cm.display), wrapping = cm.options.lineWrapping;
+    var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);
+    return function(line) {
+      if (lineIsHidden(cm.doc, line)) return 0;
+
+      var widgetsHeight = 0;
+      if (line.widgets) for (var i = 0; i < line.widgets.length; i++) {
+        if (line.widgets[i].height) widgetsHeight += line.widgets[i].height;
+      }
+
+      if (wrapping)
+        return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th;
+      else
+        return widgetsHeight + th;
+    };
+  }
+
+  function estimateLineHeights(cm) {
+    var doc = cm.doc, est = estimateHeight(cm);
+    doc.iter(function(line) {
+      var estHeight = est(line);
+      if (estHeight != line.height) updateLineHeight(line, estHeight);
+    });
+  }
+
+  function themeChanged(cm) {
+    cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
+      cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");
+    clearCaches(cm);
+  }
+
+  function guttersChanged(cm) {
+    updateGutters(cm);
+    regChange(cm);
+    setTimeout(function(){alignHorizontally(cm);}, 20);
+  }
+
+  // Rebuild the gutter elements, ensure the margin to the left of the
+  // code matches their width.
+  function updateGutters(cm) {
+    var gutters = cm.display.gutters, specs = cm.options.gutters;
+    removeChildren(gutters);
+    for (var i = 0; i < specs.length; ++i) {
+      var gutterClass = specs[i];
+      var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass));
+      if (gutterClass == "CodeMirror-linenumbers") {
+        cm.display.lineGutter = gElt;
+        gElt.style.width = (cm.display.lineNumWidth || 1) + "px";
+      }
+    }
+    gutters.style.display = i ? "" : "none";
+    updateGutterSpace(cm);
+  }
+
+  function updateGutterSpace(cm) {
+    var width = cm.display.gutters.offsetWidth;
+    cm.display.sizer.style.marginLeft = width + "px";
+  }
+
+  // Compute the character length of a line, taking into account
+  // collapsed ranges (see markText) that might hide parts, and join
+  // other lines onto it.
+  function lineLength(line) {
+    if (line.height == 0) return 0;
+    var len = line.text.length, merged, cur = line;
+    while (merged = collapsedSpanAtStart(cur)) {
+      var found = merged.find(0, true);
+      cur = found.from.line;
+      len += found.from.ch - found.to.ch;
+    }
+    cur = line;
+    while (merged = collapsedSpanAtEnd(cur)) {
+      var found = merged.find(0, true);
+      len -= cur.text.length - found.from.ch;
+      cur = found.to.line;
+      len += cur.text.length - found.to.ch;
+    }
+    return len;
+  }
+
+  // Find the longest line in the document.
+  function findMaxLine(cm) {
+    var d = cm.display, doc = cm.doc;
+    d.maxLine = getLine(doc, doc.first);
+    d.maxLineLength = lineLength(d.maxLine);
+    d.maxLineChanged = true;
+    doc.iter(function(line) {
+      var len = lineLength(line);
+      if (len > d.maxLineLength) {
+        d.maxLineLength = len;
+        d.maxLine = line;
+      }
+    });
+  }
+
+  // Make sure the gutters options contains the element
+  // "CodeMirror-linenumbers" when the lineNumbers option is true.
+  function setGuttersForLineNumbers(options) {
+    var found = indexOf(options.gutters, "CodeMirror-linenumbers");
+    if (found == -1 && options.lineNumbers) {
+      options.gutters = options.gutters.concat(["CodeMirror-linenumbers"]);
+    } else if (found > -1 && !options.lineNumbers) {
+      options.gutters = options.gutters.slice(0);
+      options.gutters.splice(found, 1);
+    }
+  }
+
+  // SCROLLBARS
+
+  // Prepare DOM reads needed to update the scrollbars. Done in one
+  // shot to minimize update/measure roundtrips.
+  function measureForScrollbars(cm) {
+    var d = cm.display, gutterW = d.gutters.offsetWidth;
+    var docH = Math.round(cm.doc.height + paddingVert(cm.display));
+    return {
+      clientHeight: d.scroller.clientHeight,
+      viewHeight: d.wrapper.clientHeight,
+      scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,
+      viewWidth: d.wrapper.clientWidth,
+      barLeft: cm.options.fixedGutter ? gutterW : 0,
+      docHeight: docH,
+      scrollHeight: docH + scrollGap(cm) + d.barHeight,
+      nativeBarWidth: d.nativeBarWidth,
+      gutterWidth: gutterW
+    };
+  }
+
+  function NativeScrollbars(place, scroll, cm) {
+    this.cm = cm;
+    var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar");
+    var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar");
+    place(vert); place(horiz);
+
+    on(vert, "scroll", function() {
+      if (vert.clientHeight) scroll(vert.scrollTop, "vertical");
+    });
+    on(horiz, "scroll", function() {
+      if (horiz.clientWidth) scroll(horiz.scrollLeft, "horizontal");
+    });
+
+    this.checkedOverlay = false;
+    // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
+    if (ie && ie_version < 8) this.horiz.style.minHeight = this.vert.style.minWidth = "18px";
+  }
+
+  NativeScrollbars.prototype = copyObj({
+    update: function(measure) {
+      var needsH = measure.scrollWidth > measure.clientWidth + 1;
+      var needsV = measure.scrollHeight > measure.clientHeight + 1;
+      var sWidth = measure.nativeBarWidth;
+
+      if (needsV) {
+        this.vert.style.display = "block";
+        this.vert.style.bottom = needsH ? sWidth + "px" : "0";
+        var totalHeight = measure.viewHeight - (needsH ? sWidth : 0);
+        // A bug in IE8 can cause this value to be negative, so guard it.
+        this.vert.firstChild.style.height =
+          Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px";
+      } else {
+        this.vert.style.display = "";
+        this.vert.firstChild.style.height = "0";
+      }
+
+      if (needsH) {
+        this.horiz.style.display = "block";
+        this.horiz.style.right = needsV ? sWidth + "px" : "0";
+        this.horiz.style.left = measure.barLeft + "px";
+        var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0);
+        this.horiz.firstChild.style.width =
+          (measure.scrollWidth - measure.clientWidth + totalWidth) + "px";
+      } else {
+        this.horiz.style.display = "";
+        this.horiz.firstChild.style.width = "0";
+      }
+
+      if (!this.checkedOverlay && measure.clientHeight > 0) {
+        if (sWidth == 0) this.overlayHack();
+        this.checkedOverlay = true;
+      }
+
+      return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0};
+    },
+    setScrollLeft: function(pos) {
+      if (this.horiz.scrollLeft != pos) this.horiz.scrollLeft = pos;
+    },
+    setScrollTop: function(pos) {
+      if (this.vert.scrollTop != pos) this.vert.scrollTop = pos;
+    },
+    overlayHack: function() {
+      var w = mac && !mac_geMountainLion ? "12px" : "18px";
+      this.horiz.style.minHeight = this.vert.style.minWidth = w;
+      var self = this;
+      var barMouseDown = function(e) {
+        if (e_target(e) != self.vert && e_target(e) != self.horiz)
+          operation(self.cm, onMouseDown)(e);
+      };
+      on(this.vert, "mousedown", barMouseDown);
+      on(this.horiz, "mousedown", barMouseDown);
+    },
+    clear: function() {
+      var parent = this.horiz.parentNode;
+      parent.removeChild(this.horiz);
+      parent.removeChild(this.vert);
+    }
+  }, NativeScrollbars.prototype);
+
+  function NullScrollbars() {}
+
+  NullScrollbars.prototype = copyObj({
+    update: function() { return {bottom: 0, right: 0}; },
+    setScrollLeft: function() {},
+    setScrollTop: function() {},
+    clear: function() {}
+  }, NullScrollbars.prototype);
+
+  CodeMirror.scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars};
+
+  function initScrollbars(cm) {
+    if (cm.display.scrollbars) {
+      cm.display.scrollbars.clear();
+      if (cm.display.scrollbars.addClass)
+        rmClass(cm.display.wrapper, cm.display.scrollbars.addClass);
+    }
+
+    cm.display.scrollbars = new CodeMirror.scrollbarModel[cm.options.scrollbarStyle](function(node) {
+      cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller);
+      // Prevent clicks in the scrollbars from killing focus
+      on(node, "mousedown", function() {
+        if (cm.state.focused) setTimeout(function() { cm.display.input.focus(); }, 0);
+      });
+      node.setAttribute("cm-not-content", "true");
+    }, function(pos, axis) {
+      if (axis == "horizontal") setScrollLeft(cm, pos);
+      else setScrollTop(cm, pos);
+    }, cm);
+    if (cm.display.scrollbars.addClass)
+      addClass(cm.display.wrapper, cm.display.scrollbars.addClass);
+  }
+
+  function updateScrollbars(cm, measure) {
+    if (!measure) measure = measureForScrollbars(cm);
+    var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight;
+    updateScrollbarsInner(cm, measure);
+    for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {
+      if (startWidth != cm.display.barWidth && cm.options.lineWrapping)
+        updateHeightsInViewport(cm);
+      updateScrollbarsInner(cm, measureForScrollbars(cm));
+      startWidth = cm.display.barWidth; startHeight = cm.display.barHeight;
+    }
+  }
+
+  // Re-synchronize the fake scrollbars with the actual size of the
+  // content.
+  function updateScrollbarsInner(cm, measure) {
+    var d = cm.display;
+    var sizes = d.scrollbars.update(measure);
+
+    d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px";
+    d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px";
+
+    if (sizes.right && sizes.bottom) {
+      d.scrollbarFiller.style.display = "block";
+      d.scrollbarFiller.style.height = sizes.bottom + "px";
+      d.scrollbarFiller.style.width = sizes.right + "px";
+    } else d.scrollbarFiller.style.display = "";
+    if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
+      d.gutterFiller.style.display = "block";
+      d.gutterFiller.style.height = sizes.bottom + "px";
+      d.gutterFiller.style.width = measure.gutterWidth + "px";
+    } else d.gutterFiller.style.display = "";
+  }
+
+  // Compute the lines that are visible in a given viewport (defaults
+  // the the current scroll position). viewport may contain top,
+  // height, and ensure (see op.scrollToPos) properties.
+  function visibleLines(display, doc, viewport) {
+    var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop;
+    top = Math.floor(top - paddingTop(display));
+    var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight;
+
+    var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom);
+    // Ensure is a {from: {line, ch}, to: {line, ch}} object, and
+    // forces those lines into the viewport (if possible).
+    if (viewport && viewport.ensure) {
+      var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line;
+      if (ensureFrom < from) {
+        from = ensureFrom;
+        to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight);
+      } else if (Math.min(ensureTo, doc.lastLine()) >= to) {
+        from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight);
+        to = ensureTo;
+      }
+    }
+    return {from: from, to: Math.max(to, from + 1)};
+  }
+
+  // LINE NUMBERS
+
+  // Re-align line numbers and gutter marks to compensate for
+  // horizontal scrolling.
+  function alignHorizontally(cm) {
+    var display = cm.display, view = display.view;
+    if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) return;
+    var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft;
+    var gutterW = display.gutters.offsetWidth, left = comp + "px";
+    for (var i = 0; i < view.length; i++) if (!view[i].hidden) {
+      if (cm.options.fixedGutter && view[i].gutter)
+        view[i].gutter.style.left = left;
+      var align = view[i].alignable;
+      if (align) for (var j = 0; j < align.length; j++)
+        align[j].style.left = left;
+    }
+    if (cm.options.fixedGutter)
+      display.gutters.style.left = (comp + gutterW) + "px";
+  }
+
+  // Used to ensure that the line number gutter is still the right
+  // size for the current document size. Returns true when an update
+  // is needed.
+  function maybeUpdateLineNumberWidth(cm) {
+    if (!cm.options.lineNumbers) return false;
+    var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display;
+    if (last.length != display.lineNumChars) {
+      var test = display.measure.appendChild(elt("div", [elt("div", last)],
+                                                 "CodeMirror-linenumber CodeMirror-gutter-elt"));
+      var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW;
+      display.lineGutter.style.width = "";
+      display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1;
+      display.lineNumWidth = display.lineNumInnerWidth + padding;
+      display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;
+      display.lineGutter.style.width = display.lineNumWidth + "px";
+      updateGutterSpace(cm);
+      return true;
+    }
+    return false;
+  }
+
+  function lineNumberFor(options, i) {
+    return String(options.lineNumberFormatter(i + options.firstLineNumber));
+  }
+
+  // Computes display.scroller.scrollLeft + display.gutters.offsetWidth,
+  // but using getBoundingClientRect to get a sub-pixel-accurate
+  // result.
+  function compensateForHScroll(display) {
+    return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left;
+  }
+
+  // DISPLAY DRAWING
+
+  function DisplayUpdate(cm, viewport, force) {
+    var display = cm.display;
+
+    this.viewport = viewport;
+    // Store some values that we'll need later (but don't want to force a relayout for)
+    this.visible = visibleLines(display, cm.doc, viewport);
+    this.editorIsHidden = !display.wrapper.offsetWidth;
+    this.wrapperHeight = display.wrapper.clientHeight;
+    this.wrapperWidth = display.wrapper.clientWidth;
+    this.oldDisplayWidth = displayWidth(cm);
+    this.force = force;
+    this.dims = getDimensions(cm);
+    this.events = [];
+  }
+
+  DisplayUpdate.prototype.signal = function(emitter, type) {
+    if (hasHandler(emitter, type))
+      this.events.push(arguments);
+  };
+  DisplayUpdate.prototype.finish = function() {
+    for (var i = 0; i < this.events.length; i++)
+      signal.apply(null, this.events[i]);
+  };
+
+  function maybeClipScrollbars(cm) {
+    var display = cm.display;
+    if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
+      display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth;
+      display.heightForcer.style.height = scrollGap(cm) + "px";
+      display.sizer.style.marginBottom = -display.nativeBarWidth + "px";
+      display.sizer.style.borderRightWidth = scrollGap(cm) + "px";
+      display.scrollbarsClipped = true;
+    }
+  }
+
+  // Does the actual updating of the line display. Bails out
+  // (returning false) when there is nothing to be done and forced is
+  // false.
+  function updateDisplayIfNeeded(cm, update) {
+    var display = cm.display, doc = cm.doc;
+
+    if (update.editorIsHidden) {
+      resetView(cm);
+      return false;
+    }
+
+    // Bail out if the visible area is already rendered and nothing changed.
+    if (!update.force &&
+        update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&
+        (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&
+        display.renderedView == display.view && countDirtyView(cm) == 0)
+      return false;
+
+    if (maybeUpdateLineNumberWidth(cm)) {
+      resetView(cm);
+      update.dims = getDimensions(cm);
+    }
+
+    // Compute a suitable new viewport (from & to)
+    var end = doc.first + doc.size;
+    var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first);
+    var to = Math.min(end, update.visible.to + cm.options.viewportMargin);
+    if (display.viewFrom < from && from - display.viewFrom < 20) from = Math.max(doc.first, display.viewFrom);
+    if (display.viewTo > to && display.viewTo - to < 20) to = Math.min(end, display.viewTo);
+    if (sawCollapsedSpans) {
+      from = visualLineNo(cm.doc, from);
+      to = visualLineEndNo(cm.doc, to);
+    }
+
+    var different = from != display.viewFrom || to != display.viewTo ||
+      display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth;
+    adjustView(cm, from, to);
+
+    display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom));
+    // Position the mover div to align with the current scroll position
+    cm.display.mover.style.top = display.viewOffset + "px";
+
+    var toUpdate = countDirtyView(cm);
+    if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&
+        (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))
+      return false;
+
+    // For big changes, we hide the enclosing element during the
+    // update, since that speeds up the operations on most browsers.
+    var focused = activeElt();
+    if (toUpdate > 4) display.lineDiv.style.display = "none";
+    patchDisplay(cm, display.updateLineNumbers, update.dims);
+    if (toUpdate > 4) display.lineDiv.style.display = "";
+    display.renderedView = display.view;
+    // There might have been a widget with a focused element that got
+    // hidden or updated, if so re-focus it.
+    if (focused && activeElt() != focused && focused.offsetHeight) focused.focus();
+
+    // Prevent selection and cursors from interfering with the scroll
+    // width and height.
+    removeChildren(display.cursorDiv);
+    removeChildren(display.selectionDiv);
+    display.gutters.style.height = 0;
+
+    if (different) {
+      display.lastWrapHeight = update.wrapperHeight;
+      display.lastWrapWidth = update.wrapperWidth;
+      startWorker(cm, 400);
+    }
+
+    display.updateLineNumbers = null;
+
+    return true;
+  }
+
+  function postUpdateDisplay(cm, update) {
+    var viewport = update.viewport;
+    for (var first = true;; first = false) {
+      if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {
+        // Clip forced viewport to actual scrollable area.
+        if (viewport && viewport.top != null)
+          viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)};
+        // Updated line heights might result in the drawn area not
+        // actually covering the viewport. Keep looping until it does.
+        update.visible = visibleLines(cm.display, cm.doc, viewport);
+        if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)
+          break;
+      }
+      if (!updateDisplayIfNeeded(cm, update)) break;
+      updateHeightsInViewport(cm);
+      var barMeasure = measureForScrollbars(cm);
+      updateSelection(cm);
+      setDocumentHeight(cm, barMeasure);
+      updateScrollbars(cm, barMeasure);
+    }
+
+    update.signal(cm, "update", cm);
+    if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {
+      update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo);
+      cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo;
+    }
+  }
+
+  function updateDisplaySimple(cm, viewport) {
+    var update = new DisplayUpdate(cm, viewport);
+    if (updateDisplayIfNeeded(cm, update)) {
+      updateHeightsInViewport(cm);
+      postUpdateDisplay(cm, update);
+      var barMeasure = measureForScrollbars(cm);
+      updateSelection(cm);
+      setDocumentHeight(cm, barMeasure);
+      updateScrollbars(cm, barMeasure);
+      update.finish();
+    }
+  }
+
+  function setDocumentHeight(cm, measure) {
+    cm.display.sizer.style.minHeight = measure.docHeight + "px";
+    var total = measure.docHeight + cm.display.barHeight;
+    cm.display.heightForcer.style.top = total + "px";
+    cm.display.gutters.style.height = Math.max(total + scrollGap(cm), measure.clientHeight) + "px";
+  }
+
+  // Read the actual heights of the rendered lines, and update their
+  // stored heights to match.
+  function updateHeightsInViewport(cm) {
+    var display = cm.display;
+    var prevBottom = display.lineDiv.offsetTop;
+    for (var i = 0; i < display.view.length; i++) {
+      var cur = display.view[i], height;
+      if (cur.hidden) continue;
+      if (ie && ie_version < 8) {
+        var bot = cur.node.offsetTop + cur.node.offsetHeight;
+        height = bot - prevBottom;
+        prevBottom = bot;
+      } else {
+        var box = cur.node.getBoundingClientRect();
+        height = box.bottom - box.top;
+      }
+      var diff = cur.line.height - height;
+      if (height < 2) height = textHeight(display);
+      if (diff > .001 || diff < -.001) {
+        updateLineHeight(cur.line, height);
+        updateWidgetHeight(cur.line);
+        if (cur.rest) for (var j = 0; j < cur.rest.length; j++)
+          updateWidgetHeight(cur.rest[j]);
+      }
+    }
+  }
+
+  // Read and store the height of line widgets associated with the
+  // given line.
+  function updateWidgetHeight(line) {
+    if (line.widgets) for (var i = 0; i < line.widgets.length; ++i)
+      line.widgets[i].height = line.widgets[i].node.offsetHeight;
+  }
+
+  // Do a bulk-read of the DOM positions and sizes needed to draw the
+  // view, so that we don't interleave reading and writing to the DOM.
+  function getDimensions(cm) {
+    var d = cm.display, left = {}, width = {};
+    var gutterLeft = d.gutters.clientLeft;
+    for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {
+      left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft;
+      width[cm.options.gutters[i]] = n.clientWidth;
+    }
+    return {fixedPos: compensateForHScroll(d),
+            gutterTotalWidth: d.gutters.offsetWidth,
+            gutterLeft: left,
+            gutterWidth: width,
+            wrapperWidth: d.wrapper.clientWidth};
+  }
+
+  // Sync the actual display DOM structure with display.view, removing
+  // nodes for lines that are no longer in view, and creating the ones
+  // that are not there yet, and updating the ones that are out of
+  // date.
+  function patchDisplay(cm, updateNumbersFrom, dims) {
+    var display = cm.display, lineNumbers = cm.options.lineNumbers;
+    var container = display.lineDiv, cur = container.firstChild;
+
+    function rm(node) {
+      var next = node.nextSibling;
+      // Works around a throw-scroll bug in OS X Webkit
+      if (webkit && mac && cm.display.currentWheelTarget == node)
+        node.style.display = "none";
+      else
+        node.parentNode.removeChild(node);
+      return next;
+    }
+
+    var view = display.view, lineN = display.viewFrom;
+    // Loop over the elements in the view, syncing cur (the DOM nodes
+    // in display.lineDiv) with the view as we go.
+    for (var i = 0; i < view.length; i++) {
+      var lineView = view[i];
+      if (lineView.hidden) {
+      } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet
+        var node = buildLineElement(cm, lineView, lineN, dims);
+        container.insertBefore(node, cur);
+      } else { // Already drawn
+        while (cur != lineView.node) cur = rm(cur);
+        var updateNumber = lineNumbers && updateNumbersFrom != null &&
+          updateNumbersFrom <= lineN && lineView.lineNumber;
+        if (lineView.changes) {
+          if (indexOf(lineView.changes, "gutter") > -1) updateNumber = false;
+          updateLineForChanges(cm, lineView, lineN, dims);
+        }
+        if (updateNumber) {
+          removeChildren(lineView.lineNumber);
+          lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)));
+        }
+        cur = lineView.node.nextSibling;
+      }
+      lineN += lineView.size;
+    }
+    while (cur) cur = rm(cur);
+  }
+
+  // When an aspect of a line changes, a string is added to
+  // lineView.changes. This updates the relevant part of the line's
+  // DOM structure.
+  function updateLineForChanges(cm, lineView, lineN, dims) {
+    for (var j = 0; j < lineView.changes.length; j++) {
+      var type = lineView.changes[j];
+      if (type == "text") updateLineText(cm, lineView);
+      else if (type == "gutter") updateLineGutter(cm, lineView, lineN, dims);
+      else if (type == "class") updateLineClasses(lineView);
+      else if (type == "widget") updateLineWidgets(cm, lineView, dims);
+    }
+    lineView.changes = null;
+  }
+
+  // Lines with gutter elements, widgets or a background class need to
+  // be wrapped, and have the extra elements added to the wrapper div
+  function ensureLineWrapped(lineView) {
+    if (lineView.node == lineView.text) {
+      lineView.node = elt("div", null, null, "position: relative");
+      if (lineView.text.parentNode)
+        lineView.text.parentNode.replaceChild(lineView.node, lineView.text);
+      lineView.node.appendChild(lineView.text);
+      if (ie && ie_version < 8) lineView.node.style.zIndex = 2;
+    }
+    return lineView.node;
+  }
+
+  function updateLineBackground(lineView) {
+    var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass;
+    if (cls) cls += " CodeMirror-linebackground";
+    if (lineView.background) {
+      if (cls) lineView.background.className = cls;
+      else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null; }
+    } else if (cls) {
+      var wrap = ensureLineWrapped(lineView);
+      lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild);
+    }
+  }
+
+  // Wrapper around buildLineContent which will reuse the structure
+  // in display.externalMeasured when possible.
+  function getLineContent(cm, lineView) {
+    var ext = cm.display.externalMeasured;
+    if (ext && ext.line == lineView.line) {
+      cm.display.externalMeasured = null;
+      lineView.measure = ext.measure;
+      return ext.built;
+    }
+    return buildLineContent(cm, lineView);
+  }
+
+  // Redraw the line's text. Interacts with the background and text
+  // classes because the mode may output tokens that influence these
+  // classes.
+  function updateLineText(cm, lineView) {
+    var cls = lineView.text.className;
+    var built = getLineContent(cm, lineView);
+    if (lineView.text == lineView.node) lineView.node = built.pre;
+    lineView.text.parentNode.replaceChild(built.pre, lineView.text);
+    lineView.text = built.pre;
+    if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
+      lineView.bgClass = built.bgClass;
+      lineView.textClass = built.textClass;
+      updateLineClasses(lineView);
+    } else if (cls) {
+      lineView.text.className = cls;
+    }
+  }
+
+  function updateLineClasses(lineView) {
+    updateLineBackground(lineView);
+    if (lineView.line.wrapClass)
+      ensureLineWrapped(lineView).className = lineView.line.wrapClass;
+    else if (lineView.node != lineView.text)
+      lineView.node.className = "";
+    var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass;
+    lineView.text.className = textClass || "";
+  }
+
+  function updateLineGutter(cm, lineView, lineN, dims) {
+    if (lineView.gutter) {
+      lineView.node.removeChild(lineView.gutter);
+      lineView.gutter = null;
+    }
+    var markers = lineView.line.gutterMarkers;
+    if (cm.options.lineNumbers || markers) {
+      var wrap = ensureLineWrapped(lineView);
+      var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", "left: " +
+                                             (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) +
+                                             "px; width: " + dims.gutterTotalWidth + "px");
+      cm.display.input.setUneditable(gutterWrap);
+      wrap.insertBefore(gutterWrap, lineView.text);
+      if (lineView.line.gutterClass)
+        gutterWrap.className += " " + lineView.line.gutterClass;
+      if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
+        lineView.lineNumber = gutterWrap.appendChild(
+          elt("div", lineNumberFor(cm.options, lineN),
+              "CodeMirror-linenumber CodeMirror-gutter-elt",
+              "left: " + dims.gutterLeft["CodeMirror-linenumbers"] + "px; width: "
+              + cm.display.lineNumInnerWidth + "px"));
+      if (markers) for (var k = 0; k < cm.options.gutters.length; ++k) {
+        var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id];
+        if (found)
+          gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt", "left: " +
+                                     dims.gutterLeft[id] + "px; width: " + dims.gutterWidth[id] + "px"));
+      }
+    }
+  }
+
+  function updateLineWidgets(cm, lineView, dims) {
+    if (lineView.alignable) lineView.alignable = null;
+    for (var node = lineView.node.firstChild, next; node; node = next) {
+      var next = node.nextSibling;
+      if (node.className == "CodeMirror-linewidget")
+        lineView.node.removeChild(node);
+    }
+    insertLineWidgets(cm, lineView, dims);
+  }
+
+  // Build a line's DOM representation from scratch
+  function buildLineElement(cm, lineView, lineN, dims) {
+    var built = getLineContent(cm, lineView);
+    lineView.text = lineView.node = built.pre;
+    if (built.bgClass) lineView.bgClass = built.bgClass;
+    if (built.textClass) lineView.textClass = built.textClass;
+
+    updateLineClasses(lineView);
+    updateLineGutter(cm, lineView, lineN, dims);
+    insertLineWidgets(cm, lineView, dims);
+    return lineView.node;
+  }
+
+  // A lineView may contain multiple logical lines (when merged by
+  // collapsed spans). The widgets for all of them need to be drawn.
+  function insertLineWidgets(cm, lineView, dims) {
+    insertLineWidgetsFor(cm, lineView.line, lineView, dims, true);
+    if (lineView.rest) for (var i = 0; i < lineView.rest.length; i++)
+      insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false);
+  }
+
+  function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
+    if (!line.widgets) return;
+    var wrap = ensureLineWrapped(lineView);
+    for (var i = 0, ws = line.widgets; i < ws.length; ++i) {
+      var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget");
+      if (!widget.handleMouseEvents) node.setAttribute("cm-ignore-events", "true");
+      positionLineWidget(widget, node, lineView, dims);
+      cm.display.input.setUneditable(node);
+      if (allowAbove && widget.above)
+        wrap.insertBefore(node, lineView.gutter || lineView.text);
+      else
+        wrap.appendChild(node);
+      signalLater(widget, "redraw");
+    }
+  }
+
+  function positionLineWidget(widget, node, lineView, dims) {
+    if (widget.noHScroll) {
+      (lineView.alignable || (lineView.alignable = [])).push(node);
+      var width = dims.wrapperWidth;
+      node.style.left = dims.fixedPos + "px";
+      if (!widget.coverGutter) {
+        width -= dims.gutterTotalWidth;
+        node.style.paddingLeft = dims.gutterTotalWidth + "px";
+      }
+      node.style.width = width + "px";
+    }
+    if (widget.coverGutter) {
+      node.style.zIndex = 5;
+      node.style.position = "relative";
+      if (!widget.noHScroll) node.style.marginLeft = -dims.gutterTotalWidth + "px";
+    }
+  }
+
+  // POSITION OBJECT
+
+  // A Pos instance represents a position within the text.
+  var Pos = CodeMirror.Pos = function(line, ch) {
+    if (!(this instanceof Pos)) return new Pos(line, ch);
+    this.line = line; this.ch = ch;
+  };
+
+  // Compare two positions, return 0 if they are the same, a negative
+  // number when a is less, and a positive number otherwise.
+  var cmp = CodeMirror.cmpPos = function(a, b) { return a.line - b.line || a.ch - b.ch; };
+
+  function copyPos(x) {return Pos(x.line, x.ch);}
+  function maxPos(a, b) { return cmp(a, b) < 0 ? b : a; }
+  function minPos(a, b) { return cmp(a, b) < 0 ? a : b; }
+
+  // INPUT HANDLING
+
+  function ensureFocus(cm) {
+    if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm); }
+  }
+
+  function isReadOnly(cm) {
+    return cm.options.readOnly || cm.doc.cantEdit;
+  }
+
+  // This will be set to an array of strings when copying, so that,
+  // when pasting, we know what kind of selections the copied text
+  // was made out of.
+  var lastCopied = null;
+
+  function applyTextInput(cm, inserted, deleted, sel, origin) {
+    var doc = cm.doc;
+    cm.display.shift = false;
+    if (!sel) sel = doc.sel;
+
+    var paste = cm.state.pasteIncoming || origin == "paste";
+    var textLines = splitLines(inserted), multiPaste = null;
+    // When pasing N lines into N selections, insert one line per selection
+    if (paste && sel.ranges.length > 1) {
+      if (lastCopied && lastCopied.join("\n") == inserted)
+        multiPaste = sel.ranges.length % lastCopied.length == 0 && map(lastCopied, splitLines);
+      else if (textLines.length == sel.ranges.length)
+        multiPaste = map(textLines, function(l) { return [l]; });
+    }
+
+    // Normal behavior is to insert the new text into every selection
+    for (var i = sel.ranges.length - 1; i >= 0; i--) {
+      var range = sel.ranges[i];
+      var from = range.from(), to = range.to();
+      if (range.empty()) {
+        if (deleted && deleted > 0) // Handle deletion
+          from = Pos(from.line, from.ch - deleted);
+        else if (cm.state.overwrite && !paste) // Handle overwrite
+          to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length));
+      }
+      var updateInput = cm.curOp.updateInput;
+      var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i % multiPaste.length] : textLines,
+                         origin: origin || (paste ? "paste" : cm.state.cutIncoming ? "cut" : "+input")};
+      makeChange(cm.doc, changeEvent);
+      signalLater(cm, "inputRead", cm, changeEvent);
+    }
+    if (inserted && !paste)
+      triggerElectric(cm, inserted);
+
+    ensureCursorVisible(cm);
+    cm.curOp.updateInput = updateInput;
+    cm.curOp.typing = true;
+    cm.state.pasteIncoming = cm.state.cutIncoming = false;
+  }
+
+  function handlePaste(e, cm) {
+    var pasted = e.clipboardData && e.clipboardData.getData("text/plain");
+    if (pasted) {
+      e.preventDefault();
+      runInOp(cm, function() { applyTextInput(cm, pasted, 0, null, "paste"); });
+      return true;
+    }
+  }
+
+  function triggerElectric(cm, inserted) {
+    // When an 'electric' character is inserted, immediately trigger a reindent
+    if (!cm.options.electricChars || !cm.options.smartIndent) return;
+    var sel = cm.doc.sel;
+
+    for (var i = sel.ranges.length - 1; i >= 0; i--) {
+      var range = sel.ranges[i];
+      if (range.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range.head.line)) continue;
+      var mode = cm.getModeAt(range.head);
+      var indented = false;
+      if (mode.electricChars) {
+        for (var j = 0; j < mode.electricChars.length; j++)
+          if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {
+            indented = indentLine(cm, range.head.line, "smart");
+            break;
+          }
+      } else if (mode.electricInput) {
+        if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch)))
+          indented = indentLine(cm, range.head.line, "smart");
+      }
+      if (indented) signalLater(cm, "electricInput", cm, range.head.line);
+    }
+  }
+
+  function copyableRanges(cm) {
+    var text = [], ranges = [];
+    for (var i = 0; i < cm.doc.sel.ranges.length; i++) {
+      var line = cm.doc.sel.ranges[i].head.line;
+      var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)};
+      ranges.push(lineRange);
+      text.push(cm.getRange(lineRange.anchor, lineRange.head));
+    }
+    return {text: text, ranges: ranges};
+  }
+
+  function disableBrowserMagic(field) {
+    field.setAttribute("autocorrect", "off");
+    field.setAttribute("autocapitalize", "off");
+    field.setAttribute("spellcheck", "false");
+  }
+
+  // TEXTAREA INPUT STYLE
+
+  function TextareaInput(cm) {
+    this.cm = cm;
+    // See input.poll and input.reset
+    this.prevInput = "";
+
+    // Flag that indicates whether we expect input to appear real soon
+    // now (after some event like 'keypress' or 'input') and are
+    // polling intensively.
+    this.pollingFast = false;
+    // Self-resetting timeout for the poller
+    this.polling = new Delayed();
+    // Tracks when input.reset has punted to just putting a short
+    // string into the textarea instead of the full selection.
+    this.inaccurateSelection = false;
+    // Used to work around IE issue with selection being forgotten when focus moves away from textarea
+    this.hasSelection = false;
+    this.composing = null;
+  };
+
+  function hiddenTextarea() {
+    var te = elt("textarea", null, null, "position: absolute; padding: 0; width: 1px; height: 1em; outline: none");
+    var div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;");
+    // The textarea is kept positioned near the cursor to prevent the
+    // fact that it'll be scrolled into view on input from scrolling
+    // our fake cursor out of view. On webkit, when wrap=off, paste is
+    // very slow. So make the area wide instead.
+    if (webkit) te.style.width = "1000px";
+    else te.setAttribute("wrap", "off");
+    // If border: 0; -- iOS fails to open keyboard (issue #1287)
+    if (ios) te.style.border = "1px solid black";
+    disableBrowserMagic(te);
+    return div;
+  }
+
+  TextareaInput.prototype = copyObj({
+    init: function(display) {
+      var input = this, cm = this.cm;
+
+      // Wraps and hides input textarea
+      var div = this.wrapper = hiddenTextarea();
+      // The semihidden textarea that is focused when the editor is
+      // focused, and receives input.
+      var te = this.textarea = div.firstChild;
+      display.wrapper.insertBefore(div, display.wrapper.firstChild);
+
+      // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)
+      if (ios) te.style.width = "0px";
+
+      on(te, "input", function() {
+        if (ie && ie_version >= 9 && input.hasSelection) input.hasSelection = null;
+        input.poll();
+      });
+
+      on(te, "paste", function(e) {
+        if (handlePaste(e, cm)) return true;
+
+        cm.state.pasteIncoming = true;
+        input.fastPoll();
+      });
+
+      function prepareCopyCut(e) {
+        if (cm.somethingSelected()) {
+          lastCopied = cm.getSelections();
+          if (input.inaccurateSelection) {
+            input.prevInput = "";
+            input.inaccurateSelection = false;
+            te.value = lastCopied.join("\n");
+            selectInput(te);
+          }
+        } else if (!cm.options.lineWiseCopyCut) {
+          return;
+        } else {
+          var ranges = copyableRanges(cm);
+          lastCopied = ranges.text;
+          if (e.type == "cut") {
+            cm.setSelections(ranges.ranges, null, sel_dontScroll);
+          } else {
+            input.prevInput = "";
+            te.value = ranges.text.join("\n");
+            selectInput(te);
+          }
+        }
+        if (e.type == "cut") cm.state.cutIncoming = true;
+      }
+      on(te, "cut", prepareCopyCut);
+      on(te, "copy", prepareCopyCut);
+
+      on(display.scroller, "paste", function(e) {
+        if (eventInWidget(display, e)) return;
+        cm.state.pasteIncoming = true;
+        input.focus();
+      });
+
+      // Prevent normal selection in the editor (we handle our own)
+      on(display.lineSpace, "selectstart", function(e) {
+        if (!eventInWidget(display, e)) e_preventDefault(e);
+      });
+
+      on(te, "compositionstart", function() {
+        var start = cm.getCursor("from");
+        input.composing = {
+          start: start,
+          range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"})
+        };
+      });
+      on(te, "compositionend", function() {
+        if (input.composing) {
+          input.poll();
+          input.composing.range.clear();
+          input.composing = null;
+        }
+      });
+    },
+
+    prepareSelection: function() {
+      // Redraw the selection and/or cursor
+      var cm = this.cm, display = cm.display, doc = cm.doc;
+      var result = prepareSelection(cm);
+
+      // Move the hidden textarea near the cursor to prevent scrolling artifacts
+      if (cm.options.moveInputWithCursor) {
+        var headPos = cursorCoords(cm, doc.sel.primary().head, "div");
+        var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect();
+        result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
+                                            headPos.top + lineOff.top - wrapOff.top));
+        result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
+                                             headPos.left + lineOff.left - wrapOff.left));
+      }
+
+      return result;
+    },
+
+    showSelection: function(drawn) {
+      var cm = this.cm, display = cm.display;
+      removeChildrenAndAdd(display.cursorDiv, drawn.cursors);
+      removeChildrenAndAdd(display.selectionDiv, drawn.selection);
+      if (drawn.teTop != null) {
+        this.wrapper.style.top = drawn.teTop + "px";
+        this.wrapper.style.left = drawn.teLeft + "px";
+      }
+    },
+
+    // Reset the input to correspond to the selection (or to be empty,
+    // when not typing and nothing is selected)
+    reset: function(typing) {
+      if (this.contextMenuPending) return;
+      var minimal, selected, cm = this.cm, doc = cm.doc;
+      if (cm.somethingSelected()) {
+        this.prevInput = "";
+        var range = doc.sel.primary();
+        minimal = hasCopyEvent &&
+          (range.to().line - range.from().line > 100 || (selected = cm.getSelection()).length > 1000);
+        var content = minimal ? "-" : selected || cm.getSelection();
+        this.textarea.value = content;
+        if (cm.state.focused) selectInput(this.textarea);
+        if (ie && ie_version >= 9) this.hasSelection = content;
+      } else if (!typing) {
+        this.prevInput = this.textarea.value = "";
+        if (ie && ie_version >= 9) this.hasSelection = null;
+      }
+      this.inaccurateSelection = minimal;
+    },
+
+    getField: function() { return this.textarea; },
+
+    supportsTouch: function() { return false; },
+
+    focus: function() {
+      if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) {
+        try { this.textarea.focus(); }
+        catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM
+      }
+    },
+
+    blur: function() { this.textarea.blur(); },
+
+    resetPosition: function() {
+      this.wrapper.style.top = this.wrapper.style.left = 0;
+    },
+
+    receivedFocus: function() { this.slowPoll(); },
+
+    // Poll for input changes, using the normal rate of polling. This
+    // runs as long as the editor is focused.
+    slowPoll: function() {
+      var input = this;
+      if (input.pollingFast) return;
+      input.polling.set(this.cm.options.pollInterval, function() {
+        input.poll();
+        if (input.cm.state.focused) input.slowPoll();
+      });
+    },
+
+    // When an event has just come in that is likely to add or change
+    // something in the input textarea, we poll faster, to ensure that
+    // the change appears on the screen quickly.
+    fastPoll: function() {
+      var missed = false, input = this;
+      input.pollingFast = true;
+      function p() {
+        var changed = input.poll();
+        if (!changed && !missed) {missed = true; input.polling.set(60, p);}
+        else {input.pollingFast = false; input.slowPoll();}
+      }
+      input.polling.set(20, p);
+    },
+
+    // Read input from the textarea, and update the document to match.
+    // When something is selected, it is present in the textarea, and
+    // selected (unless it is huge, in which case a placeholder is
+    // used). When nothing is selected, the cursor sits after previously
+    // seen text (can be empty), which is stored in prevInput (we must
+    // not reset the textarea when typing, because that breaks IME).
+    poll: function() {
+      var cm = this.cm, input = this.textarea, prevInput = this.prevInput;
+      // Since this is called a *lot*, try to bail out as cheaply as
+      // possible when it is clear that nothing happened. hasSelection
+      // will be the case when there is a lot of text in the textarea,
+      // in which case reading its value would be expensive.
+      if (this.contextMenuPending || !cm.state.focused ||
+          (hasSelection(input) && !prevInput) ||
+          isReadOnly(cm) || cm.options.disableInput || cm.state.keySeq)
+        return false;
+
+      var text = input.value;
+      // If nothing changed, bail.
+      if (text == prevInput && !cm.somethingSelected()) return false;
+      // Work around nonsensical selection resetting in IE9/10, and
+      // inexplicable appearance of private area unicode characters on
+      // some key combos in Mac (#2689).
+      if (ie && ie_version >= 9 && this.hasSelection === text ||
+          mac && /[\uf700-\uf7ff]/.test(text)) {
+        cm.display.input.reset();
+        return false;
+      }
+
+      if (cm.doc.sel == cm.display.selForContextMenu) {
+        var first = text.charCodeAt(0);
+        if (first == 0x200b && !prevInput) prevInput = "\u200b";
+        if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo"); }
+      }
+      // Find the part of the input that is actually new
+      var same = 0, l = Math.min(prevInput.length, text.length);
+      while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) ++same;
+
+      var self = this;
+      runInOp(cm, function() {
+        applyTextInput(cm, text.slice(same), prevInput.length - same,
+                       null, self.composing ? "*compose" : null);
+
+        // Don't leave long text in the textarea, since it makes further polling slow
+        if (text.length > 1000 || text.indexOf("\n") > -1) input.value = self.prevInput = "";
+        else self.prevInput = text;
+
+        if (self.composing) {
+          self.composing.range.clear();
+          self.composing.range = cm.markText(self.composing.start, cm.getCursor("to"),
+                                             {className: "CodeMirror-composing"});
+        }
+      });
+      return true;
+    },
+
+    ensurePolled: function() {
+      if (this.pollingFast && this.poll()) this.pollingFast = false;
+    },
+
+    onKeyPress: function() {
+      if (ie && ie_version >= 9) this.hasSelection = null;
+      this.fastPoll();
+    },
+
+    onContextMenu: function(e) {
+      var input = this, cm = input.cm, display = cm.display, te = input.textarea;
+      var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop;
+      if (!pos || presto) return; // Opera is difficult.
+
+      // Reset the current text selection only if the click is done outside of the selection
+      // and 'resetSelectionOnContextMenu' option is true.
+      var reset = cm.options.resetSelectionOnContextMenu;
+      if (reset && cm.doc.sel.contains(pos) == -1)
+        operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll);
+
+      var oldCSS = te.style.cssText;
+      input.wrapper.style.position = "absolute";
+      te.style.cssText = "position: fixed; width: 30px; height: 30px; top: " + (e.clientY - 5) +
+        "px; left: " + (e.clientX - 5) + "px; z-index: 1000; background: " +
+        (ie ? "rgba(255, 255, 255, .05)" : "transparent") +
+        "; outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);";
+      if (webkit) var oldScrollY = window.scrollY; // Work around Chrome issue (#2712)
+      display.input.focus();
+      if (webkit) window.scrollTo(null, oldScrollY);
+      display.input.reset();
+      // Adds "Select all" to context menu in FF
+      if (!cm.somethingSelected()) te.value = input.prevInput = " ";
+      input.contextMenuPending = true;
+      display.selForContextMenu = cm.doc.sel;
+      clearTimeout(display.detectingSelectAll);
+
+      // Select-all will be greyed out if there's nothing to select, so
+      // this adds a zero-width space so that we can later check whether
+      // it got selected.
+      function prepareSelectAllHack() {
+        if (te.selectionStart != null) {
+          var selected = cm.somethingSelected();
+          var extval = "\u200b" + (selected ? te.value : "");
+          te.value = "\u21da"; // Used to catch context-menu undo
+          te.value = extval;
+          input.prevInput = selected ? "" : "\u200b";
+          te.selectionStart = 1; te.selectionEnd = extval.length;
+          // Re-set this, in case some other handler touched the
+          // selection in the meantime.
+          display.selForContextMenu = cm.doc.sel;
+        }
+      }
+      function rehide() {
+        input.contextMenuPending = false;
+        input.wrapper.style.position = "relative";
+        te.style.cssText = oldCSS;
+        if (ie && ie_version < 9) display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos);
+
+        // Try to detect the user choosing select-all
+        if (te.selectionStart != null) {
+          if (!ie || (ie && ie_version < 9)) prepareSelectAllHack();
+          var i = 0, poll = function() {
+            if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&
+                te.selectionEnd > 0 && input.prevInput == "\u200b")
+              operation(cm, commands.selectAll)(cm);
+            else if (i++ < 10) display.detectingSelectAll = setTimeout(poll, 500);
+            else display.input.reset();
+          };
+          display.detectingSelectAll = setTimeout(poll, 200);
+        }
+      }
+
+      if (ie && ie_version >= 9) prepareSelectAllHack();
+      if (captureRightClick) {
+        e_stop(e);
+        var mouseup = function() {
+          off(window, "mouseup", mouseup);
+          setTimeout(rehide, 20);
+        };
+        on(window, "mouseup", mouseup);
+      } else {
+        setTimeout(rehide, 50);
+      }
+    },
+
+    setUneditable: nothing,
+
+    needsContentAttribute: false
+  }, TextareaInput.prototype);
+
+  // CONTENTEDITABLE INPUT STYLE
+
+  function ContentEditableInput(cm) {
+    this.cm = cm;
+    this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null;
+    this.polling = new Delayed();
+    this.gracePeriod = false;
+  }
+
+  ContentEditableInput.prototype = copyObj({
+    init: function(display) {
+      var input = this, cm = input.cm;
+      var div = input.div = display.lineDiv;
+      div.contentEditable = "true";
+      disableBrowserMagic(div);
+
+      on(div, "paste", function(e) { handlePaste(e, cm); })
+
+      on(div, "compositionstart", function(e) {
+        var data = e.data;
+        input.composing = {sel: cm.doc.sel, data: data, startData: data};
+        if (!data) return;
+        var prim = cm.doc.sel.primary();
+        var line = cm.getLine(prim.head.line);
+        var found = line.indexOf(data, Math.max(0, prim.head.ch - data.length));
+        if (found > -1 && found <= prim.head.ch)
+          input.composing.sel = simpleSelection(Pos(prim.head.line, found),
+                                                Pos(prim.head.line, found + data.length));
+      });
+      on(div, "compositionupdate", function(e) {
+        input.composing.data = e.data;
+      });
+      on(div, "compositionend", function(e) {
+        var ours = input.composing;
+        if (!ours) return;
+        if (e.data != ours.startData && !/\u200b/.test(e.data))
+          ours.data = e.data;
+        // Need a small delay to prevent other code (input event,
+        // selection polling) from doing damage when fired right after
+        // compositionend.
+        setTimeout(function() {
+          if (!ours.handled)
+            input.applyComposition(ours);
+          if (input.composing == ours)
+            input.composing = null;
+        }, 50);
+      });
+
+      on(div, "touchstart", function() {
+        input.forceCompositionEnd();
+      });
+
+      on(div, "input", function() {
+        if (input.composing) return;
+        if (!input.pollContent())
+          runInOp(input.cm, function() {regChange(cm);});
+      });
+
+      function onCopyCut(e) {
+        if (cm.somethingSelected()) {
+          lastCopied = cm.getSelections();
+          if (e.type == "cut") cm.replaceSelection("", null, "cut");
+        } else if (!cm.options.lineWiseCopyCut) {
+          return;
+        } else {
+          var ranges = copyableRanges(cm);
+          lastCopied = ranges.text;
+          if (e.type == "cut") {
+            cm.operation(function() {
+              cm.setSelections(ranges.ranges, 0, sel_dontScroll);
+              cm.replaceSelection("", null, "cut");
+            });
+          }
+        }
+        // iOS exposes the clipboard API, but seems to discard content inserted into it
+        if (e.clipboardData && !ios) {
+          e.preventDefault();
+          e.clipboardData.clearData();
+          e.clipboardData.setData("text/plain", lastCopied.join("\n"));
+        } else {
+          // Old-fashioned briefly-focus-a-textarea hack
+          var kludge = hiddenTextarea(), te = kludge.firstChild;
+          cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild);
+          te.value = lastCopied.join("\n");
+          var hadFocus = document.activeElement;
+          selectInput(te);
+          setTimeout(function() {
+            cm.display.lineSpace.removeChild(kludge);
+            hadFocus.focus();
+          }, 50);
+        }
+      }
+      on(div, "copy", onCopyCut);
+      on(div, "cut", onCopyCut);
+    },
+
+    prepareSelection: function() {
+      var result = prepareSelection(this.cm, false);
+      result.focus = this.cm.state.focused;
+      return result;
+    },
+
+    showSelection: function(info) {
+      if (!info || !this.cm.display.view.length) return;
+      if (info.focus) this.showPrimarySelection();
+      this.showMultipleSelections(info);
+    },
+
+    showPrimarySelection: function() {
+      var sel = window.getSelection(), prim = this.cm.doc.sel.primary();
+      var curAnchor = domToPos(this.cm, sel.anchorNode, sel.anchorOffset);
+      var curFocus = domToPos(this.cm, sel.focusNode, sel.focusOffset);
+      if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&
+          cmp(minPos(curAnchor, curFocus), prim.from()) == 0 &&
+          cmp(maxPos(curAnchor, curFocus), prim.to()) == 0)
+        return;
+
+      var start = posToDOM(this.cm, prim.from());
+      var end = posToDOM(this.cm, prim.to());
+      if (!start && !end) return;
+
+      var view = this.cm.display.view;
+      var old = sel.rangeCount && sel.getRangeAt(0);
+      if (!start) {
+        start = {node: view[0].measure.map[2], offset: 0};
+      } else if (!end) { // FIXME dangerously hacky
+        var measure = view[view.length - 1].measure;
+        var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map;
+        end = {node: map[map.length - 1], offset: map[map.length - 2] - map[map.length - 3]};
+      }
+
+      try { var rng = range(start.node, start.offset, end.offset, end.node); }
+      catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible
+      if (rng) {
+        sel.removeAllRanges();
+        sel.addRange(rng);
+        if (old && sel.anchorNode == null) sel.addRange(old);
+        else if (gecko) this.startGracePeriod();
+      }
+      this.rememberSelection();
+    },
+
+    startGracePeriod: function() {
+      var input = this;
+      clearTimeout(this.gracePeriod);
+      this.gracePeriod = setTimeout(function() {
+        input.gracePeriod = false;
+        if (input.selectionChanged())
+          input.cm.operation(function() { input.cm.curOp.selectionChanged = true; });
+      }, 20);
+    },
+
+    showMultipleSelections: function(info) {
+      removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors);
+      removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection);
+    },
+
+    rememberSelection: function() {
+      var sel = window.getSelection();
+      this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset;
+      this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset;
+    },
+
+    selectionInEditor: function() {
+      var sel = window.getSelection();
+      if (!sel.rangeCount) return false;
+      var node = sel.getRangeAt(0).commonAncestorContainer;
+      return contains(this.div, node);
+    },
+
+    focus: function() {
+      if (this.cm.options.readOnly != "nocursor") this.div.focus();
+    },
+    blur: function() { this.div.blur(); },
+    getField: function() { return this.div; },
+
+    supportsTouch: function() { return true; },
+
+    receivedFocus: function() {
+      var input = this;
+      if (this.selectionInEditor())
+        this.pollSelection();
+      else
+        runInOp(this.cm, function() { input.cm.curOp.selectionChanged = true; });
+
+      function poll() {
+        if (input.cm.state.focused) {
+          input.pollSelection();
+          input.polling.set(input.cm.options.pollInterval, poll);
+        }
+      }
+      this.polling.set(this.cm.options.pollInterval, poll);
+    },
+
+    selectionChanged: function() {
+      var sel = window.getSelection();
+      return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||
+        sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset;
+    },
+
+    pollSelection: function() {
+      if (!this.composing && !this.gracePeriod && this.selectionChanged()) {
+        var sel = window.getSelection(), cm = this.cm;
+        this.rememberSelection();
+        var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);
+        var head = domToPos(cm, sel.focusNode, sel.focusOffset);
+        if (anchor && head) runInOp(cm, function() {
+          setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll);
+          if (anchor.bad || head.bad) cm.curOp.selectionChanged = true;
+        });
+      }
+    },
+
+    pollContent: function() {
+      var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary();
+      var from = sel.from(), to = sel.to();
+      if (from.line < display.viewFrom || to.line > display.viewTo - 1) return false;
+
+      var fromIndex;
+      if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {
+        var fromLine = lineNo(display.view[0].line);
+        var fromNode = display.view[0].node;
+      } else {
+        var fromLine = lineNo(display.view[fromIndex].line);
+        var fromNode = display.view[fromIndex - 1].node.nextSibling;
+      }
+      var toIndex = findViewIndex(cm, to.line);
+      if (toIndex == display.view.length - 1) {
+        var toLine = display.viewTo - 1;
+        var toNode = display.lineDiv.lastChild;
+      } else {
+        var toLine = lineNo(display.view[toIndex + 1].line) - 1;
+        var toNode = display.view[toIndex + 1].node.previousSibling;
+      }
+
+      var newText = splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine));
+      var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length));
+      while (newText.length > 1 && oldText.length > 1) {
+        if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine--; }
+        else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++; }
+        else break;
+      }
+
+      var cutFront = 0, cutEnd = 0;
+      var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length);
+      while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))
+        ++cutFront;
+      var newBot = lst(newText), oldBot = lst(oldText);
+      var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),
+                               oldBot.length - (oldText.length == 1 ? cutFront : 0));
+      while (cutEnd < maxCutEnd &&
+             newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))
+        ++cutEnd;
+
+      newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd);
+      newText[0] = newText[0].slice(cutFront);
+
+      var chFrom = Pos(fromLine, cutFront);
+      var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0);
+      if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {
+        replaceRange(cm.doc, newText, chFrom, chTo, "+input");
+        return true;
+      }
+    },
+
+    ensurePolled: function() {
+      this.forceCompositionEnd();
+    },
+    reset: function() {
+      this.forceCompositionEnd();
+    },
+    forceCompositionEnd: function() {
+      if (!this.composing || this.composing.handled) return;
+      this.applyComposition(this.composing);
+      this.composing.handled = true;
+      this.div.blur();
+      this.div.focus();
+    },
+    applyComposition: function(composing) {
+      if (composing.data && composing.data != composing.startData)
+        operation(this.cm, applyTextInput)(this.cm, composing.data, 0, composing.sel);
+    },
+
+    setUneditable: function(node) {
+      node.setAttribute("contenteditable", "false");
+    },
+
+    onKeyPress: function(e) {
+      e.preventDefault();
+      operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0);
+    },
+
+    onContextMenu: nothing,
+    resetPosition: nothing,
+
+    needsContentAttribute: true
+  }, ContentEditableInput.prototype);
+
+  function posToDOM(cm, pos) {
+    var view = findViewForLine(cm, pos.line);
+    if (!view || view.hidden) return null;
+    var line = getLine(cm.doc, pos.line);
+    var info = mapFromLineView(view, line, pos.line);
+
+    var order = getOrder(line), side = "left";
+    if (order) {
+      var partPos = getBidiPartAt(order, pos.ch);
+      side = partPos % 2 ? "right" : "left";
+    }
+    var result = nodeAndOffsetInLineMap(info.map, pos.ch, side);
+    result.offset = result.collapse == "right" ? result.end : result.start;
+    return result;
+  }
+
+  function badPos(pos, bad) { if (bad) pos.bad = true; return pos; }
+
+  function domToPos(cm, node, offset) {
+    var lineNode;
+    if (node == cm.display.lineDiv) {
+      lineNode = cm.display.lineDiv.childNodes[offset];
+      if (!lineNode) return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true);
+      node = null; offset = 0;
+    } else {
+      for (lineNode = node;; lineNode = lineNode.parentNode) {
+        if (!lineNode || lineNode == cm.display.lineDiv) return null;
+        if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) break;
+      }
+    }
+    for (var i = 0; i < cm.display.view.length; i++) {
+      var lineView = cm.display.view[i];
+      if (lineView.node == lineNode)
+        return locateNodeInLineView(lineView, node, offset);
+    }
+  }
+
+  function locateNodeInLineView(lineView, node, offset) {
+    var wrapper = lineView.text.firstChild, bad = false;
+    if (!node || !contains(wrapper, node)) return badPos(Pos(lineNo(lineView.line), 0), true);
+    if (node == wrapper) {
+      bad = true;
+      node = wrapper.childNodes[offset];
+      offset = 0;
+      if (!node) {
+        var line = lineView.rest ? lst(lineView.rest) : lineView.line;
+        return badPos(Pos(lineNo(line), line.text.length), bad);
+      }
+    }
+
+    var textNode = node.nodeType == 3 ? node : null, topNode = node;
+    if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {
+      textNode = node.firstChild;
+      if (offset) offset = textNode.nodeValue.length;
+    }
+    while (topNode.parentNode != wrapper) topNode = topNode.parentNode;
+    var measure = lineView.measure, maps = measure.maps;
+
+    function find(textNode, topNode, offset) {
+      for (var i = -1; i < (maps ? maps.length : 0); i++) {
+        var map = i < 0 ? measure.map : maps[i];
+        for (var j = 0; j < map.length; j += 3) {
+          var curNode = map[j + 2];
+          if (curNode == textNode || curNode == topNode) {
+            var line = lineNo(i < 0 ? lineView.line : lineView.rest[i]);
+            var ch = map[j] + offset;
+            if (offset < 0 || curNode != textNode) ch = map[j + (offset ? 1 : 0)];
+            return Pos(line, ch);
+          }
+        }
+      }
+    }
+    var found = find(textNode, topNode, offset);
+    if (found) return badPos(found, bad);
+
+    // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems
+    for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {
+      found = find(after, after.firstChild, 0);
+      if (found)
+        return badPos(Pos(found.line, found.ch - dist), bad);
+      else
+        dist += after.textContent.length;
+    }
+    for (var before = topNode.previousSibling, dist = offset; before; before = before.previousSibling) {
+      found = find(before, before.firstChild, -1);
+      if (found)
+        return badPos(Pos(found.line, found.ch + dist), bad);
+      else
+        dist += after.textContent.length;
+    }
+  }
+
+  function domTextBetween(cm, from, to, fromLine, toLine) {
+    var text = "", closing = false;
+    function recognizeMarker(id) { return function(marker) { return marker.id == id; }; }
+    function walk(node) {
+      if (node.nodeType == 1) {
+        var cmText = node.getAttribute("cm-text");
+        if (cmText != null) {
+          if (cmText == "") cmText = node.textContent.replace(/\u200b/g, "");
+          text += cmText;
+          return;
+        }
+        var markerID = node.getAttribute("cm-marker"), range;
+        if (markerID) {
+          var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID));
+          if (found.length && (range = found[0].find()))
+            text += getBetween(cm.doc, range.from, range.to).join("\n");
+          return;
+        }
+        if (node.getAttribute("contenteditable") == "false") return;
+        for (var i = 0; i < node.childNodes.length; i++)
+          walk(node.childNodes[i]);
+        if (/^(pre|div|p)$/i.test(node.nodeName))
+          closing = true;
+      } else if (node.nodeType == 3) {
+        var val = node.nodeValue;
+        if (!val) return;
+        if (closing) {
+          text += "\n";
+          closing = false;
+        }
+        text += val;
+      }
+    }
+    for (;;) {
+      walk(from);
+      if (from == to) break;
+      from = from.nextSibling;
+    }
+    return text;
+  }
+
+  CodeMirror.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput};
+
+  // SELECTION / CURSOR
+
+  // Selection objects are immutable. A new one is created every time
+  // the selection changes. A selection is one or more non-overlapping
+  // (and non-touching) ranges, sorted, and an integer that indicates
+  // which one is the primary selection (the one that's scrolled into
+  // view, that getCursor returns, etc).
+  function Selection(ranges, primIndex) {
+    this.ranges = ranges;
+    this.primIndex = primIndex;
+  }
+
+  Selection.prototype = {
+    primary: function() { return this.ranges[this.primIndex]; },
+    equals: function(other) {
+      if (other == this) return true;
+      if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) return false;
+      for (var i = 0; i < this.ranges.length; i++) {
+        var here = this.ranges[i], there = other.ranges[i];
+        if (cmp(here.anchor, there.anchor) != 0 || cmp(here.head, there.head) != 0) return false;
+      }
+      return true;
+    },
+    deepCopy: function() {
+      for (var out = [], i = 0; i < this.ranges.length; i++)
+        out[i] = new Range(copyPos(this.ranges[i].anchor), copyPos(this.ranges[i].head));
+      return new Selection(out, this.primIndex);
+    },
+    somethingSelected: function() {
+      for (var i = 0; i < this.ranges.length; i++)
+        if (!this.ranges[i].empty()) return true;
+      return false;
+    },
+    contains: function(pos, end) {
+      if (!end) end = pos;
+      for (var i = 0; i < this.ranges.length; i++) {
+        var range = this.ranges[i];
+        if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)
+          return i;
+      }
+      return -1;
+    }
+  };
+
+  function Range(anchor, head) {
+    this.anchor = anchor; this.head = head;
+  }
+
+  Range.prototype = {
+    from: function() { return minPos(this.anchor, this.head); },
+    to: function() { return maxPos(this.anchor, this.head); },
+    empty: function() {
+      return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch;
+    }
+  };
+
+  // Take an unsorted, potentially overlapping set of ranges, and
+  // build a selection out of it. 'Consumes' ranges array (modifying
+  // it).
+  function normalizeSelection(ranges, primIndex) {
+    var prim = ranges[primIndex];
+    ranges.sort(function(a, b) { return cmp(a.from(), b.from()); });
+    primIndex = indexOf(ranges, prim);
+    for (var i = 1; i < ranges.length; i++) {
+      var cur = ranges[i], prev = ranges[i - 1];
+      if (cmp(prev.to(), cur.from()) >= 0) {
+        var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to());
+        var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head;
+        if (i <= primIndex) --primIndex;
+        ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to));
+      }
+    }
+    return new Selection(ranges, primIndex);
+  }
+
+  function simpleSelection(anchor, head) {
+    return new Selection([new Range(anchor, head || anchor)], 0);
+  }
+
+  // Most of the external API clips given positions to make sure they
+  // actually exist within the document.
+  function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1));}
+  function clipPos(doc, pos) {
+    if (pos.line < doc.first) return Pos(doc.first, 0);
+    var last = doc.first + doc.size - 1;
+    if (pos.line > last) return Pos(last, getLine(doc, last).text.length);
+    return clipToLen(pos, getLine(doc, pos.line).text.length);
+  }
+  function clipToLen(pos, linelen) {
+    var ch = pos.ch;
+    if (ch == null || ch > linelen) return Pos(pos.line, linelen);
+    else if (ch < 0) return Pos(pos.line, 0);
+    else return pos;
+  }
+  function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size;}
+  function clipPosArray(doc, array) {
+    for (var out = [], i = 0; i < array.length; i++) out[i] = clipPos(doc, array[i]);
+    return out;
+  }
+
+  // SELECTION UPDATES
+
+  // The 'scroll' parameter given to many of these indicated whether
+  // the new cursor position should be scrolled into view after
+  // modifying the selection.
+
+  // If shift is held or the extend flag is set, extends a range to
+  // include a given position (and optionally a second position).
+  // Otherwise, simply returns the range between the given positions.
+  // Used for cursor motion and such.
+  function extendRange(doc, range, head, other) {
+    if (doc.cm && doc.cm.display.shift || doc.extend) {
+      var anchor = range.anchor;
+      if (other) {
+        var posBefore = cmp(head, anchor) < 0;
+        if (posBefore != (cmp(other, anchor) < 0)) {
+          anchor = head;
+          head = other;
+        } else if (posBefore != (cmp(head, other) < 0)) {
+          head = other;
+        }
+      }
+      return new Range(anchor, head);
+    } else {
+      return new Range(other || head, head);
+    }
+  }
+
+  // Extend the primary selection range, discard the rest.
+  function extendSelection(doc, head, other, options) {
+    setSelection(doc, new Selection([extendRange(doc, doc.sel.primary(), head, other)], 0), options);
+  }
+
+  // Extend all selections (pos is an array of selections with length
+  // equal the number of selections)
+  function extendSelections(doc, heads, options) {
+    for (var out = [], i = 0; i < doc.sel.ranges.length; i++)
+      out[i] = extendRange(doc, doc.sel.ranges[i], heads[i], null);
+    var newSel = normalizeSelection(out, doc.sel.primIndex);
+    setSelection(doc, newSel, options);
+  }
+
+  // Updates a single range in the selection.
+  function replaceOneSelection(doc, i, range, options) {
+    var ranges = doc.sel.ranges.slice(0);
+    ranges[i] = range;
+    setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options);
+  }
+
+  // Reset the selection to a single range.
+  function setSimpleSelection(doc, anchor, head, options) {
+    setSelection(doc, simpleSelection(anchor, head), options);
+  }
+
+  // Give beforeSelectionChange handlers a change to influence a
+  // selection update.
+  function filterSelectionChange(doc, sel) {
+    var obj = {
+      ranges: sel.ranges,
+      update: function(ranges) {
+        this.ranges = [];
+        for (var i = 0; i < ranges.length; i++)
+          this.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),
+                                     clipPos(doc, ranges[i].head));
+      }
+    };
+    signal(doc, "beforeSelectionChange", doc, obj);
+    if (doc.cm) signal(doc.cm, "beforeSelectionChange", doc.cm, obj);
+    if (obj.ranges != sel.ranges) return normalizeSelection(obj.ranges, obj.ranges.length - 1);
+    else return sel;
+  }
+
+  function setSelectionReplaceHistory(doc, sel, options) {
+    var done = doc.history.done, last = lst(done);
+    if (last && last.ranges) {
+      done[done.length - 1] = sel;
+      setSelectionNoUndo(doc, sel, options);
+    } else {
+      setSelection(doc, sel, options);
+    }
+  }
+
+  // Set a new selection.
+  function setSelection(doc, sel, options) {
+    setSelectionNoUndo(doc, sel, options);
+    addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options);
+  }
+
+  function setSelectionNoUndo(doc, sel, options) {
+    if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange"))
+      sel = filterSelectionChange(doc, sel);
+
+    var bias = options && options.bias ||
+      (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1);
+    setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true));
+
+    if (!(options && options.scroll === false) && doc.cm)
+      ensureCursorVisible(doc.cm);
+  }
+
+  function setSelectionInner(doc, sel) {
+    if (sel.equals(doc.sel)) return;
+
+    doc.sel = sel;
+
+    if (doc.cm) {
+      doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true;
+      signalCursorActivity(doc.cm);
+    }
+    signalLater(doc, "cursorActivity", doc);
+  }
+
+  // Verify that the selection does not partially select any atomic
+  // marked ranges.
+  function reCheckSelection(doc) {
+    setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false), sel_dontScroll);
+  }
+
+  // Return a selection that does not partially select any atomic
+  // ranges.
+  function skipAtomicInSelection(doc, sel, bias, mayClear) {
+    var out;
+    for (var i = 0; i < sel.ranges.length; i++) {
+      var range = sel.ranges[i];
+      var newAnchor = skipAtomic(doc, range.anchor, bias, mayClear);
+      var newHead = skipAtomic(doc, range.head, bias, mayClear);
+      if (out || newAnchor != range.anchor || newHead != range.head) {
+        if (!out) out = sel.ranges.slice(0, i);
+        out[i] = new Range(newAnchor, newHead);
+      }
+    }
+    return out ? normalizeSelection(out, sel.primIndex) : sel;
+  }
+
+  // Ensure a given position is not inside an atomic range.
+  function skipAtomic(doc, pos, bias, mayClear) {
+    var flipped = false, curPos = pos;
+    var dir = bias || 1;
+    doc.cantEdit = false;
+    search: for (;;) {
+      var line = getLine(doc, curPos.line);
+      if (line.markedSpans) {
+        for (var i = 0; i < line.markedSpans.length; ++i) {
+          var sp = line.markedSpans[i], m = sp.marker;
+          if ((sp.from == null || (m.inclusiveLeft ? sp.from <= curPos.ch : sp.from < curPos.ch)) &&
+              (sp.to == null || (m.inclusiveRight ? sp.to >= curPos.ch : sp.to > curPos.ch))) {
+            if (mayClear) {
+              signal(m, "beforeCursorEnter");
+              if (m.explicitlyCleared) {
+                if (!line.markedSpans) break;
+                else {--i; continue;}
+              }
+            }
+            if (!m.atomic) continue;
+            var newPos = m.find(dir < 0 ? -1 : 1);
+            if (cmp(newPos, curPos) == 0) {
+              newPos.ch += dir;
+              if (newPos.ch < 0) {
+                if (newPos.line > doc.first) newPos = clipPos(doc, Pos(newPos.line - 1));
+                else newPos = null;
+              } else if (newPos.ch > line.text.length) {
+                if (newPos.line < doc.first + doc.size - 1) newPos = Pos(newPos.line + 1, 0);
+                else newPos = null;
+              }
+              if (!newPos) {
+                if (flipped) {
+                  // Driven in a corner -- no valid cursor position found at all
+                  // -- try again *with* clearing, if we didn't already
+                  if (!mayClear) return skipAtomic(doc, pos, bias, true);
+                  // Otherwise, turn off editing until further notice, and return the start of the doc
+                  doc.cantEdit = true;
+                  return Pos(doc.first, 0);
+                }
+                flipped = true; newPos = pos; dir = -dir;
+              }
+            }
+            curPos = newPos;
+            continue search;
+          }
+        }
+      }
+      return curPos;
+    }
+  }
+
+  // SELECTION DRAWING
+
+  function updateSelection(cm) {
+    cm.display.input.showSelection(cm.display.input.prepareSelection());
+  }
+
+  function prepareSelection(cm, primary) {
+    var doc = cm.doc, result = {};
+    var curFragment = result.cursors = document.createDocumentFragment();
+    var selFragment = result.selection = document.createDocumentFragment();
+
+    for (var i = 0; i < doc.sel.ranges.length; i++) {
+      if (primary === false && i == doc.sel.primIndex) continue;
+      var range = doc.sel.ranges[i];
+      var collapsed = range.empty();
+      if (collapsed || cm.options.showCursorWhenSelecting)
+        drawSelectionCursor(cm, range, curFragment);
+      if (!collapsed)
+        drawSelectionRange(cm, range, selFragment);
+    }
+    return result;
+  }
+
+  // Draws a cursor for the given range
+  function drawSelectionCursor(cm, range, output) {
+    var pos = cursorCoords(cm, range.head, "div", null, null, !cm.options.singleCursorHeightPerLine);
+
+    var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"));
+    cursor.style.left = pos.left + "px";
+    cursor.style.top = pos.top + "px";
+    cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px";
+
+    if (pos.other) {
+      // Secondary cursor, shown when on a 'jump' in bi-directional text
+      var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"));
+      otherCursor.style.display = "";
+      otherCursor.style.left = pos.other.left + "px";
+      otherCursor.style.top = pos.other.top + "px";
+      otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px";
+    }
+  }
+
+  // Draws the given range as a highlighted selection
+  function drawSelectionRange(cm, range, output) {
+    var display = cm.display, doc = cm.doc;
+    var fragment = document.createDocumentFragment();
+    var padding = paddingH(cm.display), leftSide = padding.left;
+    var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right;
+
+    function add(left, top, width, bottom) {
+      if (top < 0) top = 0;
+      top = Math.round(top);
+      bottom = Math.round(bottom);
+      fragment.appendChild(elt("div", null, "CodeMirror-selected", "position: absolute; left: " + left +
+                               "px; top: " + top + "px; width: " + (width == null ? rightSide - left : width) +
+                               "px; height: " + (bottom - top) + "px"));
+    }
+
+    function drawForLine(line, fromArg, toArg) {
+      var lineObj = getLine(doc, line);
+      var lineLen = lineObj.text.length;
+      var start, end;
+      function coords(ch, bias) {
+        return charCoords(cm, Pos(line, ch), "div", lineObj, bias);
+      }
+
+      iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function(from, to, dir) {
+        var leftPos = coords(from, "left"), rightPos, left, right;
+        if (from == to) {
+          rightPos = leftPos;
+          left = right = leftPos.left;
+        } else {
+          rightPos = coords(to - 1, "right");
+          if (dir == "rtl") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp; }
+          left = leftPos.left;
+          right = rightPos.right;
+        }
+        if (fromArg == null && from == 0) left = leftSide;
+        if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part
+          add(left, leftPos.top, null, leftPos.bottom);
+          left = leftSide;
+          if (leftPos.bottom < rightPos.top) add(left, leftPos.bottom, null, rightPos.top);
+        }
+        if (toArg == null && to == lineLen) right = rightSide;
+        if (!start || leftPos.top < start.top || leftPos.top == start.top && leftPos.left < start.left)
+          start = leftPos;
+        if (!end || rightPos.bottom > end.bottom || rightPos.bottom == end.bottom && rightPos.right > end.right)
+          end = rightPos;
+        if (left < leftSide + 1) left = leftSide;
+        add(left, rightPos.top, right - left, rightPos.bottom);
+      });
+      return {start: start, end: end};
+    }
+
+    var sFrom = range.from(), sTo = range.to();
+    if (sFrom.line == sTo.line) {
+      drawForLine(sFrom.line, sFrom.ch, sTo.ch);
+    } else {
+      var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line);
+      var singleVLine = visualLine(fromLine) == visualLine(toLine);
+      var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end;
+      var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start;
+      if (singleVLine) {
+        if (leftEnd.top < rightStart.top - 2) {
+          add(leftEnd.right, leftEnd.top, null, leftEnd.bottom);
+          add(leftSide, rightStart.top, rightStart.left, rightStart.bottom);
+        } else {
+          add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom);
+        }
+      }
+      if (leftEnd.bottom < rightStart.top)
+        add(leftSide, leftEnd.bottom, null, rightStart.top);
+    }
+
+    output.appendChild(fragment);
+  }
+
+  // Cursor-blinking
+  function restartBlink(cm) {
+    if (!cm.state.focused) return;
+    var display = cm.display;
+    clearInterval(display.blinker);
+    var on = true;
+    display.cursorDiv.style.visibility = "";
+    if (cm.options.cursorBlinkRate > 0)
+      display.blinker = setInterval(function() {
+        display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden";
+      }, cm.options.cursorBlinkRate);
+    else if (cm.options.cursorBlinkRate < 0)
+      display.cursorDiv.style.visibility = "hidden";
+  }
+
+  // HIGHLIGHT WORKER
+
+  function startWorker(cm, time) {
+    if (cm.doc.mode.startState && cm.doc.frontier < cm.display.viewTo)
+      cm.state.highlight.set(time, bind(highlightWorker, cm));
+  }
+
+  function highlightWorker(cm) {
+    var doc = cm.doc;
+    if (doc.frontier < doc.first) doc.frontier = doc.first;
+    if (doc.frontier >= cm.display.viewTo) return;
+    var end = +new Date + cm.options.workTime;
+    var state = copyState(doc.mode, getStateBefore(cm, doc.frontier));
+    var changedLines = [];
+
+    doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function(line) {
+      if (doc.frontier >= cm.display.viewFrom) { // Visible
+        var oldStyles = line.styles;
+        var highlighted = highlightLine(cm, line, state, true);
+        line.styles = highlighted.styles;
+        var oldCls = line.styleClasses, newCls = highlighted.classes;
+        if (newCls) line.styleClasses = newCls;
+        else if (oldCls) line.styleClasses = null;
+        var ischange = !oldStyles || oldStyles.length != line.styles.length ||
+          oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass);
+        for (var i = 0; !ischange && i < oldStyles.length; ++i) ischange = oldStyles[i] != line.styles[i];
+        if (ischange) changedLines.push(doc.frontier);
+        line.stateAfter = copyState(doc.mode, state);
+      } else {
+        processLine(cm, line.text, state);
+        line.stateAfter = doc.frontier % 5 == 0 ? copyState(doc.mode, state) : null;
+      }
+      ++doc.frontier;
+      if (+new Date > end) {
+        startWorker(cm, cm.options.workDelay);
+        return true;
+      }
+    });
+    if (changedLines.length) runInOp(cm, function() {
+      for (var i = 0; i < changedLines.length; i++)
+        regLineChange(cm, changedLines[i], "text");
+    });
+  }
+
+  // Finds the line to start with when starting a parse. Tries to
+  // find a line with a stateAfter, so that it can start with a
+  // valid state. If that fails, it returns the line with the
+  // smallest indentation, which tends to need the least context to
+  // parse correctly.
+  function findStartLine(cm, n, precise) {
+    var minindent, minline, doc = cm.doc;
+    var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100);
+    for (var search = n; search > lim; --search) {
+      if (search <= doc.first) return doc.first;
+      var line = getLine(doc, search - 1);
+      if (line.stateAfter && (!precise || search <= doc.frontier)) return search;
+      var indented = countColumn(line.text, null, cm.options.tabSize);
+      if (minline == null || minindent > indented) {
+        minline = search - 1;
+        minindent = indented;
+      }
+    }
+    return minline;
+  }
+
+  function getStateBefore(cm, n, precise) {
+    var doc = cm.doc, display = cm.display;
+    if (!doc.mode.startState) return true;
+    var pos = findStartLine(cm, n, precise), state = pos > doc.first && getLine(doc, pos-1).stateAfter;
+    if (!state) state = startState(doc.mode);
+    else state = copyState(doc.mode, state);
+    doc.iter(pos, n, function(line) {
+      processLine(cm, line.text, state);
+      var save = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo;
+      line.stateAfter = save ? copyState(doc.mode, state) : null;
+      ++pos;
+    });
+    if (precise) doc.frontier = pos;
+    return state;
+  }
+
+  // POSITION MEASUREMENT
+
+  function paddingTop(display) {return display.lineSpace.offsetTop;}
+  function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight;}
+  function paddingH(display) {
+    if (display.cachedPaddingH) return display.cachedPaddingH;
+    var e = removeChildrenAndAdd(display.measure, elt("pre", "x"));
+    var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle;
+    var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)};
+    if (!isNaN(data.left) && !isNaN(data.right)) display.cachedPaddingH = data;
+    return data;
+  }
+
+  function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth; }
+  function displayWidth(cm) {
+    return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth;
+  }
+  function displayHeight(cm) {
+    return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight;
+  }
+
+  // Ensure the lineView.wrapping.heights array is populated. This is
+  // an array of bottom offsets for the lines that make up a drawn
+  // line. When lineWrapping is on, there might be more than one
+  // height.
+  function ensureLineHeights(cm, lineView, rect) {
+    var wrapping = cm.options.lineWrapping;
+    var curWidth = wrapping && displayWidth(cm);
+    if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {
+      var heights = lineView.measure.heights = [];
+      if (wrapping) {
+        lineView.measure.width = curWidth;
+        var rects = lineView.text.firstChild.getClientRects();
+        for (var i = 0; i < rects.length - 1; i++) {
+          var cur = rects[i], next = rects[i + 1];
+          if (Math.abs(cur.bottom - next.bottom) > 2)
+            heights.push((cur.bottom + next.top) / 2 - rect.top);
+        }
+      }
+      heights.push(rect.bottom - rect.top);
+    }
+  }
+
+  // Find a line map (mapping character offsets to text nodes) and a
+  // measurement cache for the given line number. (A line view might
+  // contain multiple lines when collapsed ranges are present.)
+  function mapFromLineView(lineView, line, lineN) {
+    if (lineView.line == line)
+      return {map: lineView.measure.map, cache: lineView.measure.cache};
+    for (var i = 0; i < lineView.rest.length; i++)
+      if (lineView.rest[i] == line)
+        return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]};
+    for (var i = 0; i < lineView.rest.length; i++)
+      if (lineNo(lineView.rest[i]) > lineN)
+        return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i], before: true};
+  }
+
+  // Render a line into the hidden node display.externalMeasured. Used
+  // when measurement is needed for a line that's not in the viewport.
+  function updateExternalMeasurement(cm, line) {
+    line = visualLine(line);
+    var lineN = lineNo(line);
+    var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN);
+    view.lineN = lineN;
+    var built = view.built = buildLineContent(cm, view);
+    view.text = built.pre;
+    removeChildrenAndAdd(cm.display.lineMeasure, built.pre);
+    return view;
+  }
+
+  // Get a {top, bottom, left, right} box (in line-local coordinates)
+  // for a given character.
+  function measureChar(cm, line, ch, bias) {
+    return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias);
+  }
+
+  // Find a line view that corresponds to the given line number.
+  function findViewForLine(cm, lineN) {
+    if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
+      return cm.display.view[findViewIndex(cm, lineN)];
+    var ext = cm.display.externalMeasured;
+    if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
+      return ext;
+  }
+
+  // Measurement can be split in two steps, the set-up work that
+  // applies to the whole line, and the measurement of the actual
+  // character. Functions like coordsChar, that need to do a lot of
+  // measurements in a row, can thus ensure that the set-up work is
+  // only done once.
+  function prepareMeasureForLine(cm, line) {
+    var lineN = lineNo(line);
+    var view = findViewForLine(cm, lineN);
+    if (view && !view.text)
+      view = null;
+    else if (view && view.changes)
+      updateLineForChanges(cm, view, lineN, getDimensions(cm));
+    if (!view)
+      view = updateExternalMeasurement(cm, line);
+
+    var info = mapFromLineView(view, line, lineN);
+    return {
+      line: line, view: view, rect: null,
+      map: info.map, cache: info.cache, before: info.before,
+      hasHeights: false
+    };
+  }
+
+  // Given a prepared measurement object, measures the position of an
+  // actual character (or fetches it from the cache).
+  function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
+    if (prepared.before) ch = -1;
+    var key = ch + (bias || ""), found;
+    if (prepared.cache.hasOwnProperty(key)) {
+      found = prepared.cache[key];
+    } else {
+      if (!prepared.rect)
+        prepared.rect = prepared.view.text.getBoundingClientRect();
+      if (!prepared.hasHeights) {
+        ensureLineHeights(cm, prepared.view, prepared.rect);
+        prepared.hasHeights = true;
+      }
+      found = measureCharInner(cm, prepared, ch, bias);
+      if (!found.bogus) prepared.cache[key] = found;
+    }
+    return {left: found.left, right: found.right,
+            top: varHeight ? found.rtop : found.top,
+            bottom: varHeight ? found.rbottom : found.bottom};
+  }
+
+  var nullRect = {left: 0, right: 0, top: 0, bottom: 0};
+
+  function nodeAndOffsetInLineMap(map, ch, bias) {
+    var node, start, end, collapse;
+    // First, search the line map for the text node corresponding to,
+    // or closest to, the target character.
+    for (var i = 0; i < map.length; i += 3) {
+      var mStart = map[i], mEnd = map[i + 1];
+      if (ch < mStart) {
+        start = 0; end = 1;
+        collapse = "left";
+      } else if (ch < mEnd) {
+        start = ch - mStart;
+        end = start + 1;
+      } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {
+        end = mEnd - mStart;
+        start = end - 1;
+        if (ch >= mEnd) collapse = "right";
+      }
+      if (start != null) {
+        node = map[i + 2];
+        if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right"))
+          collapse = bias;
+        if (bias == "left" && start == 0)
+          while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {
+            node = map[(i -= 3) + 2];
+            collapse = "left";
+          }
+        if (bias == "right" && start == mEnd - mStart)
+          while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {
+            node = map[(i += 3) + 2];
+            collapse = "right";
+          }
+        break;
+      }
+    }
+    return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd};
+  }
+
+  function measureCharInner(cm, prepared, ch, bias) {
+    var place = nodeAndOffsetInLineMap(prepared.map, ch, bias);
+    var node = place.node, start = place.start, end = place.end, collapse = place.collapse;
+
+    var rect;
+    if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.
+      for (var i = 0; i < 4; i++) { // Retry a maximum of 4 times when nonsense rectangles are returned
+        while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) --start;
+        while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) ++end;
+        if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart) {
+          rect = node.parentNode.getBoundingClientRect();
+        } else if (ie && cm.options.lineWrapping) {
+          var rects = range(node, start, end).getClientRects();
+          if (rects.length)
+            rect = rects[bias == "right" ? rects.length - 1 : 0];
+          else
+            rect = nullRect;
+        } else {
+          rect = range(node, start, end).getBoundingClientRect() || nullRect;
+        }
+        if (rect.left || rect.right || start == 0) break;
+        end = start;
+        start = start - 1;
+        collapse = "right";
+      }
+      if (ie && ie_version < 11) rect = maybeUpdateRectForZooming(cm.display.measure, rect);
+    } else { // If it is a widget, simply get the box for the whole widget.
+      if (start > 0) collapse = bias = "right";
+      var rects;
+      if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)
+        rect = rects[bias == "right" ? rects.length - 1 : 0];
+      else
+        rect = node.getBoundingClientRect();
+    }
+    if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {
+      var rSpan = node.parentNode.getClientRects()[0];
+      if (rSpan)
+        rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom};
+      else
+        rect = nullRect;
+    }
+
+    var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top;
+    var mid = (rtop + rbot) / 2;
+    var heights = prepared.view.measure.heights;
+    for (var i = 0; i < heights.length - 1; i++)
+      if (mid < heights[i]) break;
+    var top = i ? heights[i - 1] : 0, bot = heights[i];
+    var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left,
+                  right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left,
+                  top: top, bottom: bot};
+    if (!rect.left && !rect.right) result.bogus = true;
+    if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot; }
+
+    return result;
+  }
+
+  // Work around problem with bounding client rects on ranges being
+  // returned incorrectly when zoomed on IE10 and below.
+  function maybeUpdateRectForZooming(measure, rect) {
+    if (!window.screen || screen.logicalXDPI == null ||
+        screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))
+      return rect;
+    var scaleX = screen.logicalXDPI / screen.deviceXDPI;
+    var scaleY = screen.logicalYDPI / screen.deviceYDPI;
+    return {left: rect.left * scaleX, right: rect.right * scaleX,
+            top: rect.top * scaleY, bottom: rect.bottom * scaleY};
+  }
+
+  function clearLineMeasurementCacheFor(lineView) {
+    if (lineView.measure) {
+      lineView.measure.cache = {};
+      lineView.measure.heights = null;
+      if (lineView.rest) for (var i = 0; i < lineView.rest.length; i++)
+        lineView.measure.caches[i] = {};
+    }
+  }
+
+  function clearLineMeasurementCache(cm) {
+    cm.display.externalMeasure = null;
+    removeChildren(cm.display.lineMeasure);
+    for (var i = 0; i < cm.display.view.length; i++)
+      clearLineMeasurementCacheFor(cm.display.view[i]);
+  }
+
+  function clearCaches(cm) {
+    clearLineMeasurementCache(cm);
+    cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null;
+    if (!cm.options.lineWrapping) cm.display.maxLineChanged = true;
+    cm.display.lineNumChars = null;
+  }
+
+  function pageScrollX() { return window.pageXOffset || (document.documentElement || document.body).scrollLeft; }
+  function pageScrollY() { return window.pageYOffset || (document.documentElement || document.body).scrollTop; }
+
+  // Converts a {top, bottom, left, right} box from line-local
+  // coordinates into another coordinate system. Context may be one of
+  // "line", "div" (display.lineDiv), "local"/null (editor), "window",
+  // or "page".
+  function intoCoordSystem(cm, lineObj, rect, context) {
+    if (lineObj.widgets) for (var i = 0; i < lineObj.widgets.length; ++i) if (lineObj.widgets[i].above) {
+      var size = widgetHeight(lineObj.widgets[i]);
+      rect.top += size; rect.bottom += size;
+    }
+    if (context == "line") return rect;
+    if (!context) context = "local";
+    var yOff = heightAtLine(lineObj);
+    if (context == "local") yOff += paddingTop(cm.display);
+    else yOff -= cm.display.viewOffset;
+    if (context == "page" || context == "window") {
+      var lOff = cm.display.lineSpace.getBoundingClientRect();
+      yOff += lOff.top + (context == "window" ? 0 : pageScrollY());
+      var xOff = lOff.left + (context == "window" ? 0 : pageScrollX());
+      rect.left += xOff; rect.right += xOff;
+    }
+    rect.top += yOff; rect.bottom += yOff;
+    return rect;
+  }
+
+  // Coverts a box from "div" coords to another coordinate system.
+  // Context may be "window", "page", "div", or "local"/null.
+  function fromCoordSystem(cm, coords, context) {
+    if (context == "div") return coords;
+    var left = coords.left, top = coords.top;
+    // First move into "page" coordinate system
+    if (context == "page") {
+      left -= pageScrollX();
+      top -= pageScrollY();
+    } else if (context == "local" || !context) {
+      var localBox = cm.display.sizer.getBoundingClientRect();
+      left += localBox.left;
+      top += localBox.top;
+    }
+
+    var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect();
+    return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top};
+  }
+
+  function charCoords(cm, pos, context, lineObj, bias) {
+    if (!lineObj) lineObj = getLine(cm.doc, pos.line);
+    return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context);
+  }
+
+  // Returns a box for a given cursor position, which may have an
+  // 'other' property containing the position of the secondary cursor
+  // on a bidi boundary.
+  function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {
+    lineObj = lineObj || getLine(cm.doc, pos.line);
+    if (!preparedMeasure) preparedMeasure = prepareMeasureForLine(cm, lineObj);
+    function get(ch, right) {
+      var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight);
+      if (right) m.left = m.right; else m.right = m.left;
+      return intoCoordSystem(cm, lineObj, m, context);
+    }
+    function getBidi(ch, partPos) {
+      var part = order[partPos], right = part.level % 2;
+      if (ch == bidiLeft(part) && partPos && part.level < order[partPos - 1].level) {
+        part = order[--partPos];
+        ch = bidiRight(part) - (part.level % 2 ? 0 : 1);
+        right = true;
+      } else if (ch == bidiRight(part) && partPos < order.length - 1 && part.level < order[partPos + 1].level) {
+        part = order[++partPos];
+        ch = bidiLeft(part) - part.level % 2;
+        right = false;
+      }
+      if (right && ch == part.to && ch > part.from) return get(ch - 1);
+      return get(ch, right);
+    }
+    var order = getOrder(lineObj), ch = pos.ch;
+    if (!order) return get(ch);
+    var partPos = getBidiPartAt(order, ch);
+    var val = getBidi(ch, partPos);
+    if (bidiOther != null) val.other = getBidi(ch, bidiOther);
+    return val;
+  }
+
+  // Used to cheaply estimate the coordinates for a position. Used for
+  // intermediate scroll updates.
+  function estimateCoords(cm, pos) {
+    var left = 0, pos = clipPos(cm.doc, pos);
+    if (!cm.options.lineWrapping) left = charWidth(cm.display) * pos.ch;
+    var lineObj = getLine(cm.doc, pos.line);
+    var top = heightAtLine(lineObj) + paddingTop(cm.display);
+    return {left: left, right: left, top: top, bottom: top + lineObj.height};
+  }
+
+  // Positions returned by coordsChar contain some extra information.
+  // xRel is the relative x position of the input coordinates compared
+  // to the found position (so xRel > 0 means the coordinates are to
+  // the right of the character position, for example). When outside
+  // is true, that means the coordinates lie outside the line's
+  // vertical range.
+  function PosWithInfo(line, ch, outside, xRel) {
+    var pos = Pos(line, ch);
+    pos.xRel = xRel;
+    if (outside) pos.outside = true;
+    return pos;
+  }
+
+  // Compute the character position closest to the given coordinates.
+  // Input must be lineSpace-local ("div" coordinate system).
+  function coordsChar(cm, x, y) {
+    var doc = cm.doc;
+    y += cm.display.viewOffset;
+    if (y < 0) return PosWithInfo(doc.first, 0, true, -1);
+    var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1;
+    if (lineN > last)
+      return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, true, 1);
+    if (x < 0) x = 0;
+
+    var lineObj = getLine(doc, lineN);
+    for (;;) {
+      var found = coordsCharInner(cm, lineObj, lineN, x, y);
+      var merged = collapsedSpanAtEnd(lineObj);
+      var mergedPos = merged && merged.find(0, true);
+      if (merged && (found.ch > mergedPos.from.ch || found.ch == mergedPos.from.ch && found.xRel > 0))
+        lineN = lineNo(lineObj = mergedPos.to.line);
+      else
+        return found;
+    }
+  }
+
+  function coordsCharInner(cm, lineObj, lineNo, x, y) {
+    var innerOff = y - heightAtLine(lineObj);
+    var wrongLine = false, adjust = 2 * cm.display.wrapper.clientWidth;
+    var preparedMeasure = prepareMeasureForLine(cm, lineObj);
+
+    function getX(ch) {
+      var sp = cursorCoords(cm, Pos(lineNo, ch), "line", lineObj, preparedMeasure);
+      wrongLine = true;
+      if (innerOff > sp.bottom) return sp.left - adjust;
+      else if (innerOff < sp.top) return sp.left + adjust;
+      else wrongLine = false;
+      return sp.left;
+    }
+
+    var bidi = getOrder(lineObj), dist = lineObj.text.length;
+    var from = lineLeft(lineObj), to = lineRight(lineObj);
+    var fromX = getX(from), fromOutside = wrongLine, toX = getX(to), toOutside = wrongLine;
+
+    if (x > toX) return PosWithInfo(lineNo, to, toOutside, 1);
+    // Do a binary search between these bounds.
+    for (;;) {
+      if (bidi ? to == from || to == moveVisually(lineObj, from, 1) : to - from <= 1) {
+        var ch = x < fromX || x - fromX <= toX - x ? from : to;
+        var xDiff = x - (ch == from ? fromX : toX);
+        while (isExtendingChar(lineObj.text.charAt(ch))) ++ch;
+        var pos = PosWithInfo(lineNo, ch, ch == from ? fromOutside : toOutside,
+                              xDiff < -1 ? -1 : xDiff > 1 ? 1 : 0);
+        return pos;
+      }
+      var step = Math.ceil(dist / 2), middle = from + step;
+      if (bidi) {
+        middle = from;
+        for (var i = 0; i < step; ++i) middle = moveVisually(lineObj, middle, 1);
+      }
+      var middleX = getX(middle);
+      if (middleX > x) {to = middle; toX = middleX; if (toOutside = wrongLine) toX += 1000; dist = step;}
+      else {from = middle; fromX = middleX; fromOutside = wrongLine; dist -= step;}
+    }
+  }
+
+  var measureText;
+  // Compute the default text height.
+  function textHeight(display) {
+    if (display.cachedTextHeight != null) return display.cachedTextHeight;
+    if (measureText == null) {
+      measureText = elt("pre");
+      // Measure a bunch of lines, for browsers that compute
+      // fractional heights.
+      for (var i = 0; i < 49; ++i) {
+        measureText.appendChild(document.createTextNode("x"));
+        measureText.appendChild(elt("br"));
+      }
+      measureText.appendChild(document.createTextNode("x"));
+    }
+    removeChildrenAndAdd(display.measure, measureText);
+    var height = measureText.offsetHeight / 50;
+    if (height > 3) display.cachedTextHeight = height;
+    removeChildren(display.measure);
+    return height || 1;
+  }
+
+  // Compute the default character width.
+  function charWidth(display) {
+    if (display.cachedCharWidth != null) return display.cachedCharWidth;
+    var anchor = elt("span", "xxxxxxxxxx");
+    var pre = elt("pre", [anchor]);
+    removeChildrenAndAdd(display.measure, pre);
+    var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10;
+    if (width > 2) display.cachedCharWidth = width;
+    return width || 10;
+  }
+
+  // OPERATIONS
+
+  // Operations are used to wrap a series of changes to the editor
+  // state in such a way that each change won't have to update the
+  // cursor and display (which would be awkward, slow, and
+  // error-prone). Instead, display updates are batched and then all
+  // combined and executed at once.
+
+  var operationGroup = null;
+
+  var nextOpId = 0;
+  // Start a new operation.
+  function startOperation(cm) {
+    cm.curOp = {
+      cm: cm,
+      viewChanged: false,      // Flag that indicates that lines might need to be redrawn
+      startHeight: cm.doc.height, // Used to detect need to update scrollbar
+      forceUpdate: false,      // Used to force a redraw
+      updateInput: null,       // Whether to reset the input textarea
+      typing: false,           // Whether this reset should be careful to leave existing text (for compositing)
+      changeObjs: null,        // Accumulated changes, for firing change events
+      cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on
+      cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already
+      selectionChanged: false, // Whether the selection needs to be redrawn
+      updateMaxLine: false,    // Set when the widest line needs to be determined anew
+      scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet
+      scrollToPos: null,       // Used to scroll to a specific position
+      focus: false,
+      id: ++nextOpId           // Unique ID
+    };
+    if (operationGroup) {
+      operationGroup.ops.push(cm.curOp);
+    } else {
+      cm.curOp.ownsGroup = operationGroup = {
+        ops: [cm.curOp],
+        delayedCallbacks: []
+      };
+    }
+  }
+
+  function fireCallbacksForOps(group) {
+    // Calls delayed callbacks and cursorActivity handlers until no
+    // new ones appear
+    var callbacks = group.delayedCallbacks, i = 0;
+    do {
+      for (; i < callbacks.length; i++)
+        callbacks[i]();
+      for (var j = 0; j < group.ops.length; j++) {
+        var op = group.ops[j];
+        if (op.cursorActivityHandlers)
+          while (op.cursorActivityCalled < op.cursorActivityHandlers.length)
+            op.cursorActivityHandlers[op.cursorActivityCalled++](op.cm);
+      }
+    } while (i < callbacks.length);
+  }
+
+  // Finish an operation, updating the display and signalling delayed events
+  function endOperation(cm) {
+    var op = cm.curOp, group = op.ownsGroup;
+    if (!group) return;
+
+    try { fireCallbacksForOps(group); }
+    finally {
+      operationGroup = null;
+      for (var i = 0; i < group.ops.length; i++)
+        group.ops[i].cm.curOp = null;
+      endOperations(group);
+    }
+  }
+
+  // The DOM updates done when an operation finishes are batched so
+  // that the minimum number of relayouts are required.
+  function endOperations(group) {
+    var ops = group.ops;
+    for (var i = 0; i < ops.length; i++) // Read DOM
+      endOperation_R1(ops[i]);
+    for (var i = 0; i < ops.length; i++) // Write DOM (maybe)
+      endOperation_W1(ops[i]);
+    for (var i = 0; i < ops.length; i++) // Read DOM
+      endOperation_R2(ops[i]);
+    for (var i = 0; i < ops.length; i++) // Write DOM (maybe)
+      endOperation_W2(ops[i]);
+    for (var i = 0; i < ops.length; i++) // Read DOM
+      endOperation_finish(ops[i]);
+  }
+
+  function endOperation_R1(op) {
+    var cm = op.cm, display = cm.display;
+    maybeClipScrollbars(cm);
+    if (op.updateMaxLine) findMaxLine(cm);
+
+    op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||
+      op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||
+                         op.scrollToPos.to.line >= display.viewTo) ||
+      display.maxLineChanged && cm.options.lineWrapping;
+    op.update = op.mustUpdate &&
+      new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate);
+  }
+
+  function endOperation_W1(op) {
+    op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update);
+  }
+
+  function endOperation_R2(op) {
+    var cm = op.cm, display = cm.display;
+    if (op.updatedDisplay) updateHeightsInViewport(cm);
+
+    op.barMeasure = measureForScrollbars(cm);
+
+    // If the max line changed since it was last measured, measure it,
+    // and ensure the document's width matches it.
+    // updateDisplay_W2 will use these properties to do the actual resizing
+    if (display.maxLineChanged && !cm.options.lineWrapping) {
+      op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3;
+      cm.display.sizerWidth = op.adjustWidthTo;
+      op.barMeasure.scrollWidth =
+        Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth);
+      op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm));
+    }
+
+    if (op.updatedDisplay || op.selectionChanged)
+      op.preparedSelection = display.input.prepareSelection();
+  }
+
+  function endOperation_W2(op) {
+    var cm = op.cm;
+
+    if (op.adjustWidthTo != null) {
+      cm.display.sizer.style.minWidth = op.adjustWidthTo + "px";
+      if (op.maxScrollLeft < cm.doc.scrollLeft)
+        setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true);
+      cm.display.maxLineChanged = false;
+    }
+
+    if (op.preparedSelection)
+      cm.display.input.showSelection(op.preparedSelection);
+    if (op.updatedDisplay)
+      setDocumentHeight(cm, op.barMeasure);
+    if (op.updatedDisplay || op.startHeight != cm.doc.height)
+      updateScrollbars(cm, op.barMeasure);
+
+    if (op.selectionChanged) restartBlink(cm);
+
+    if (cm.state.focused && op.updateInput)
+      cm.display.input.reset(op.typing);
+    if (op.focus && op.focus == activeElt()) ensureFocus(op.cm);
+  }
+
+  function endOperation_finish(op) {
+    var cm = op.cm, display = cm.display, doc = cm.doc;
+
+    if (op.updatedDisplay) postUpdateDisplay(cm, op.update);
+
+    // Abort mouse wheel delta measurement, when scrolling explicitly
+    if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))
+      display.wheelStartX = display.wheelStartY = null;
+
+    // Propagate the scroll position to the actual DOM scroller
+    if (op.scrollTop != null && (display.scroller.scrollTop != op.scrollTop || op.forceScroll)) {
+      doc.scrollTop = Math.max(0, Math.min(display.scroller.scrollHeight - display.scroller.clientHeight, op.scrollTop));
+      display.scrollbars.setScrollTop(doc.scrollTop);
+      display.scroller.scrollTop = doc.scrollTop;
+    }
+    if (op.scrollLeft != null && (display.scroller.scrollLeft != op.scrollLeft || op.forceScroll)) {
+      doc.scrollLeft = Math.max(0, Math.min(display.scroller.scrollWidth - displayWidth(cm), op.scrollLeft));
+      display.scrollbars.setScrollLeft(doc.scrollLeft);
+      display.scroller.scrollLeft = doc.scrollLeft;
+      alignHorizontally(cm);
+    }
+    // If we need to scroll a specific position into view, do so.
+    if (op.scrollToPos) {
+      var coords = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),
+                                     clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin);
+      if (op.scrollToPos.isCursor && cm.state.focused) maybeScrollWindow(cm, coords);
+    }
+
+    // Fire events for markers that are hidden/unidden by editing or
+    // undoing
+    var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers;
+    if (hidden) for (var i = 0; i < hidden.length; ++i)
+      if (!hidden[i].lines.length) signal(hidden[i], "hide");
+    if (unhidden) for (var i = 0; i < unhidden.length; ++i)
+      if (unhidden[i].lines.length) signal(unhidden[i], "unhide");
+
+    if (display.wrapper.offsetHeight)
+      doc.scrollTop = cm.display.scroller.scrollTop;
+
+    // Fire change events, and delayed event handlers
+    if (op.changeObjs)
+      signal(cm, "changes", cm, op.changeObjs);
+    if (op.update)
+      op.update.finish();
+  }
+
+  // Run the given function in an operation
+  function runInOp(cm, f) {
+    if (cm.curOp) return f();
+    startOperation(cm);
+    try { return f(); }
+    finally { endOperation(cm); }
+  }
+  // Wraps a function in an operation. Returns the wrapped function.
+  function operation(cm, f) {
+    return function() {
+      if (cm.curOp) return f.apply(cm, arguments);
+      startOperation(cm);
+      try { return f.apply(cm, arguments); }
+      finally { endOperation(cm); }
+    };
+  }
+  // Used to add methods to editor and doc instances, wrapping them in
+  // operations.
+  function methodOp(f) {
+    return function() {
+      if (this.curOp) return f.apply(this, arguments);
+      startOperation(this);
+      try { return f.apply(this, arguments); }
+      finally { endOperation(this); }
+    };
+  }
+  function docMethodOp(f) {
+    return function() {
+      var cm = this.cm;
+      if (!cm || cm.curOp) return f.apply(this, arguments);
+      startOperation(cm);
+      try { return f.apply(this, arguments); }
+      finally { endOperation(cm); }
+    };
+  }
+
+  // VIEW TRACKING
+
+  // These objects are used to represent the visible (currently drawn)
+  // part of the document. A LineView may correspond to multiple
+  // logical lines, if those are connected by collapsed ranges.
+  function LineView(doc, line, lineN) {
+    // The starting line
+    this.line = line;
+    // Continuing lines, if any
+    this.rest = visualLineContinued(line);
+    // Number of logical lines in this visual line
+    this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1;
+    this.node = this.text = null;
+    this.hidden = lineIsHidden(doc, line);
+  }
+
+  // Create a range of LineView objects for the given lines.
+  function buildViewArray(cm, from, to) {
+    var array = [], nextPos;
+    for (var pos = from; pos < to; pos = nextPos) {
+      var view = new LineView(cm.doc, getLine(cm.doc, pos), pos);
+      nextPos = pos + view.size;
+      array.push(view);
+    }
+    return array;
+  }
+
+  // Updates the display.view data structure for a given change to the
+  // document. From and to are in pre-change coordinates. Lendiff is
+  // the amount of lines added or subtracted by the change. This is
+  // used for changes that span multiple lines, or change the way
+  // lines are divided into visual lines. regLineChange (below)
+  // registers single-line changes.
+  function regChange(cm, from, to, lendiff) {
+    if (from == null) from = cm.doc.first;
+    if (to == null) to = cm.doc.first + cm.doc.size;
+    if (!lendiff) lendiff = 0;
+
+    var display = cm.display;
+    if (lendiff && to < display.viewTo &&
+        (display.updateLineNumbers == null || display.updateLineNumbers > from))
+      display.updateLineNumbers = from;
+
+    cm.curOp.viewChanged = true;
+
+    if (from >= display.viewTo) { // Change after
+      if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)
+        resetView(cm);
+    } else if (to <= display.viewFrom) { // Change before
+      if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {
+        resetView(cm);
+      } else {
+        display.viewFrom += lendiff;
+        display.viewTo += lendiff;
+      }
+    } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap
+      resetView(cm);
+    } else if (from <= display.viewFrom) { // Top overlap
+      var cut = viewCuttingPoint(cm, to, to + lendiff, 1);
+      if (cut) {
+        display.view = display.view.slice(cut.index);
+        display.viewFrom = cut.lineN;
+        display.viewTo += lendiff;
+      } else {
+        resetView(cm);
+      }
+    } else if (to >= display.viewTo) { // Bottom overlap
+      var cut = viewCuttingPoint(cm, from, from, -1);
+      if (cut) {
+        display.view = display.view.slice(0, cut.index);
+        display.viewTo = cut.lineN;
+      } else {
+        resetView(cm);
+      }
+    } else { // Gap in the middle
+      var cutTop = viewCuttingPoint(cm, from, from, -1);
+      var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1);
+      if (cutTop && cutBot) {
+        display.view = display.view.slice(0, cutTop.index)
+          .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
+          .concat(display.view.slice(cutBot.index));
+        display.viewTo += lendiff;
+      } else {
+        resetView(cm);
+      }
+    }
+
+    var ext = display.externalMeasured;
+    if (ext) {
+      if (to < ext.lineN)
+        ext.lineN += lendiff;
+      else if (from < ext.lineN + ext.size)
+        display.externalMeasured = null;
+    }
+  }
+
+  // Register a change to a single line. Type must be one of "text",
+  // "gutter", "class", "widget"
+  function regLineChange(cm, line, type) {
+    cm.curOp.viewChanged = true;
+    var display = cm.display, ext = cm.display.externalMeasured;
+    if (ext && line >= ext.lineN && line < ext.lineN + ext.size)
+      display.externalMeasured = null;
+
+    if (line < display.viewFrom || line >= display.viewTo) return;
+    var lineView = display.view[findViewIndex(cm, line)];
+    if (lineView.node == null) return;
+    var arr = lineView.changes || (lineView.changes = []);
+    if (indexOf(arr, type) == -1) arr.push(type);
+  }
+
+  // Clear the view.
+  function resetView(cm) {
+    cm.display.viewFrom = cm.display.viewTo = cm.doc.first;
+    cm.display.view = [];
+    cm.display.viewOffset = 0;
+  }
+
+  // Find the view element corresponding to a given line. Return null
+  // when the line isn't visible.
+  function findViewIndex(cm, n) {
+    if (n >= cm.display.viewTo) return null;
+    n -= cm.display.viewFrom;
+    if (n < 0) return null;
+    var view = cm.display.view;
+    for (var i = 0; i < view.length; i++) {
+      n -= view[i].size;
+      if (n < 0) return i;
+    }
+  }
+
+  function viewCuttingPoint(cm, oldN, newN, dir) {
+    var index = findViewIndex(cm, oldN), diff, view = cm.display.view;
+    if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)
+      return {index: index, lineN: newN};
+    for (var i = 0, n = cm.display.viewFrom; i < index; i++)
+      n += view[i].size;
+    if (n != oldN) {
+      if (dir > 0) {
+        if (index == view.length - 1) return null;
+        diff = (n + view[index].size) - oldN;
+        index++;
+      } else {
+        diff = n - oldN;
+      }
+      oldN += diff; newN += diff;
+    }
+    while (visualLineNo(cm.doc, newN) != newN) {
+      if (index == (dir < 0 ? 0 : view.length - 1)) return null;
+      newN += dir * view[index - (dir < 0 ? 1 : 0)].size;
+      index += dir;
+    }
+    return {index: index, lineN: newN};
+  }
+
+  // Force the view to cover a given range, adding empty view element
+  // or clipping off existing ones as needed.
+  function adjustView(cm, from, to) {
+    var display = cm.display, view = display.view;
+    if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {
+      display.view = buildViewArray(cm, from, to);
+      display.viewFrom = from;
+    } else {
+      if (display.viewFrom > from)
+        display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view);
+      else if (display.viewFrom < from)
+        display.view = display.view.slice(findViewIndex(cm, from));
+      display.viewFrom = from;
+      if (display.viewTo < to)
+        display.view = display.view.concat(buildViewArray(cm, display.viewTo, to));
+      else if (display.viewTo > to)
+        display.view = display.view.slice(0, findViewIndex(cm, to));
+    }
+    display.viewTo = to;
+  }
+
+  // Count the number of lines in the view whose DOM representation is
+  // out of date (or nonexistent).
+  function countDirtyView(cm) {
+    var view = cm.display.view, dirty = 0;
+    for (var i = 0; i < view.length; i++) {
+      var lineView = view[i];
+      if (!lineView.hidden && (!lineView.node || lineView.changes)) ++dirty;
+    }
+    return dirty;
+  }
+
+  // EVENT HANDLERS
+
+  // Attach the necessary event handlers when initializing the editor
+  function registerEventHandlers(cm) {
+    var d = cm.display;
+    on(d.scroller, "mousedown", operation(cm, onMouseDown));
+    // Older IE's will not fire a second mousedown for a double click
+    if (ie && ie_version < 11)
+      on(d.scroller, "dblclick", operation(cm, function(e) {
+        if (signalDOMEvent(cm, e)) return;
+        var pos = posFromMouse(cm, e);
+        if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return;
+        e_preventDefault(e);
+        var word = cm.findWordAt(pos);
+        extendSelection(cm.doc, word.anchor, word.head);
+      }));
+    else
+      on(d.scroller, "dblclick", function(e) { signalDOMEvent(cm, e) || e_preventDefault(e); });
+    // Some browsers fire contextmenu *after* opening the menu, at
+    // which point we can't mess with it anymore. Context menu is
+    // handled in onMouseDown for these browsers.
+    if (!captureRightClick) on(d.scroller, "contextmenu", function(e) {onContextMenu(cm, e);});
+
+    // Used to suppress mouse event handling when a touch happens
+    var touchFinished, prevTouch = {end: 0};
+    function finishTouch() {
+      if (d.activeTouch) {
+        touchFinished = setTimeout(function() {d.activeTouch = null;}, 1000);
+        prevTouch = d.activeTouch;
+        prevTouch.end = +new Date;
+      }
+    };
+    function isMouseLikeTouchEvent(e) {
+      if (e.touches.length != 1) return false;
+      var touch = e.touches[0];
+      return touch.radiusX <= 1 && touch.radiusY <= 1;
+    }
+    function farAway(touch, other) {
+      if (other.left == null) return true;
+      var dx = other.left - touch.left, dy = other.top - touch.top;
+      return dx * dx + dy * dy > 20 * 20;
+    }
+    on(d.scroller, "touchstart", function(e) {
+      if (!isMouseLikeTouchEvent(e)) {
+        clearTimeout(touchFinished);
+        var now = +new Date;
+        d.activeTouch = {start: now, moved: false,
+                         prev: now - prevTouch.end <= 300 ? prevTouch : null};
+        if (e.touches.length == 1) {
+          d.activeTouch.left = e.touches[0].pageX;
+          d.activeTouch.top = e.touches[0].pageY;
+        }
+      }
+    });
+    on(d.scroller, "touchmove", function() {
+      if (d.activeTouch) d.activeTouch.moved = true;
+    });
+    on(d.scroller, "touchend", function(e) {
+      var touch = d.activeTouch;
+      if (touch && !eventInWidget(d, e) && touch.left != null &&
+          !touch.moved && new Date - touch.start < 300) {
+        var pos = cm.coordsChar(d.activeTouch, "page"), range;
+        if (!touch.prev || farAway(touch, touch.prev)) // Single tap
+          range = new Range(pos, pos);
+        else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
+          range = cm.findWordAt(pos);
+        else // Triple tap
+          range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)));
+        cm.setSelection(range.anchor, range.head);
+        cm.focus();
+        e_preventDefault(e);
+      }
+      finishTouch();
+    });
+    on(d.scroller, "touchcancel", finishTouch);
+
+    // Sync scrolling between fake scrollbars and real scrollable
+    // area, ensure viewport is updated when scrolling.
+    on(d.scroller, "scroll", function() {
+      if (d.scroller.clientHeight) {
+        setScrollTop(cm, d.scroller.scrollTop);
+        setScrollLeft(cm, d.scroller.scrollLeft, true);
+        signal(cm, "scroll", cm);
+      }
+    });
+
+    // Listen to wheel events in order to try and update the viewport on time.
+    on(d.scroller, "mousewheel", function(e){onScrollWheel(cm, e);});
+    on(d.scroller, "DOMMouseScroll", function(e){onScrollWheel(cm, e);});
+
+    // Prevent wrapper from ever scrolling
+    on(d.wrapper, "scroll", function() { d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; });
+
+    d.dragFunctions = {
+      simple: function(e) {if (!signalDOMEvent(cm, e)) e_stop(e);},
+      start: function(e){onDragStart(cm, e);},
+      drop: operation(cm, onDrop)
+    };
+
+    var inp = d.input.getField();
+    on(inp, "keyup", function(e) { onKeyUp.call(cm, e); });
+    on(inp, "keydown", operation(cm, onKeyDown));
+    on(inp, "keypress", operation(cm, onKeyPress));
+    on(inp, "focus", bind(onFocus, cm));
+    on(inp, "blur", bind(onBlur, cm));
+  }
+
+  function dragDropChanged(cm, value, old) {
+    var wasOn = old && old != CodeMirror.Init;
+    if (!value != !wasOn) {
+      var funcs = cm.display.dragFunctions;
+      var toggle = value ? on : off;
+      toggle(cm.display.scroller, "dragstart", funcs.start);
+      toggle(cm.display.scroller, "dragenter", funcs.simple);
+      toggle(cm.display.scroller, "dragover", funcs.simple);
+      toggle(cm.display.scroller, "drop", funcs.drop);
+    }
+  }
+
+  // Called when the window resizes
+  function onResize(cm) {
+    var d = cm.display;
+    if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth)
+      return;
+    // Might be a text scaling operation, clear size caches.
+    d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
+    d.scrollbarsClipped = false;
+    cm.setSize();
+  }
+
+  // MOUSE EVENTS
+
+  // Return true when the given mouse event happened in a widget
+  function eventInWidget(display, e) {
+    for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
+      if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") ||
+          (n.parentNode == display.sizer && n != display.mover))
+        return true;
+    }
+  }
+
+  // Given a mouse event, find the corresponding position. If liberal
+  // is false, it checks whether a gutter or scrollbar was clicked,
+  // and returns null if it was. forRect is used by rectangular
+  // selections, and tries to estimate a character position even for
+  // coordinates beyond the right of the text.
+  function posFromMouse(cm, e, liberal, forRect) {
+    var display = cm.display;
+    if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") return null;
+
+    var x, y, space = display.lineSpace.getBoundingClientRect();
+    // Fails unpredictably on IE[67] when mouse is dragged around quickly.
+    try { x = e.clientX - space.left; y = e.clientY - space.top; }
+    catch (e) { return null; }
+    var coords = coordsChar(cm, x, y), line;
+    if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {
+      var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length;
+      coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff));
+    }
+    return coords;
+  }
+
+  // A mouse down can be a single click, double click, triple click,
+  // start of selection drag, start of text drag, new cursor
+  // (ctrl-click), rectangle drag (alt-drag), or xwin
+  // middle-click-paste. Or it might be a click on something we should
+  // not interfere with, such as a scrollbar or widget.
+  function onMouseDown(e) {
+    var cm = this, display = cm.display;
+    if (display.activeTouch && display.input.supportsTouch() || signalDOMEvent(cm, e)) return;
+    display.shift = e.shiftKey;
+
+    if (eventInWidget(display, e)) {
+      if (!webkit) {
+        // Briefly turn off draggability, to allow widgets to do
+        // normal dragging things.
+        display.scroller.draggable = false;
+        setTimeout(function(){display.scroller.draggable = true;}, 100);
+      }
+      return;
+    }
+    if (clickInGutter(cm, e)) return;
+    var start = posFromMouse(cm, e);
+    window.focus();
+
+    switch (e_button(e)) {
+    case 1:
+      if (start)
+        leftButtonDown(cm, e, start);
+      else if (e_target(e) == display.scroller)
+        e_preventDefault(e);
+      break;
+    case 2:
+      if (webkit) cm.state.lastMiddleDown = +new Date;
+      if (start) extendSelection(cm.doc, start);
+      setTimeout(function() {display.input.focus();}, 20);
+      e_preventDefault(e);
+      break;
+    case 3:
+      if (captureRightClick) onContextMenu(cm, e);
+      else delayBlurEvent(cm);
+      break;
+    }
+  }
+
+  var lastClick, lastDoubleClick;
+  function leftButtonDown(cm, e, start) {
+    if (ie) setTimeout(bind(ensureFocus, cm), 0);
+    else cm.curOp.focus = activeElt();
+
+    var now = +new Date, type;
+    if (lastDoubleClick && lastDoubleClick.time > now - 400 && cmp(lastDoubleClick.pos, start) == 0) {
+      type = "triple";
+    } else if (lastClick && lastClick.time > now - 400 && cmp(lastClick.pos, start) == 0) {
+      type = "double";
+      lastDoubleClick = {time: now, pos: start};
+    } else {
+      type = "single";
+      lastClick = {time: now, pos: start};
+    }
+
+    var sel = cm.doc.sel, modifier = mac ? e.metaKey : e.ctrlKey, contained;
+    if (cm.options.dragDrop && dragAndDrop && !isReadOnly(cm) &&
+        type == "single" && (contained = sel.contains(start)) > -1 &&
+        (cmp((contained = sel.ranges[contained]).from(), start) < 0 || start.xRel > 0) &&
+        (cmp(contained.to(), start) > 0 || start.xRel < 0))
+      leftButtonStartDrag(cm, e, start, modifier);
+    else
+      leftButtonSelect(cm, e, start, type, modifier);
+  }
+
+  // Start a text drag. When it ends, see if any dragging actually
+  // happen, and treat as a click if it didn't.
+  function leftButtonStartDrag(cm, e, start, modifier) {
+    var display = cm.display, startTime = +new Date;
+    var dragEnd = operation(cm, function(e2) {
+      if (webkit) display.scroller.draggable = false;
+      cm.state.draggingText = false;
+      off(document, "mouseup", dragEnd);
+      off(display.scroller, "drop", dragEnd);
+      if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {
+        e_preventDefault(e2);
+        if (!modifier && +new Date - 200 < startTime)
+          extendSelection(cm.doc, start);
+        // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
+        if (webkit || ie && ie_version == 9)
+          setTimeout(function() {document.body.focus(); display.input.focus();}, 20);
+        else
+          display.input.focus();
+      }
+    });
+    // Let the drag handler handle this.
+    if (webkit) display.scroller.draggable = true;
+    cm.state.draggingText = dragEnd;
+    // IE's approach to draggable
+    if (display.scroller.dragDrop) display.scroller.dragDrop();
+    on(document, "mouseup", dragEnd);
+    on(display.scroller, "drop", dragEnd);
+  }
+
+  // Normal selection, as opposed to text dragging.
+  function leftButtonSelect(cm, e, start, type, addNew) {
+    var display = cm.display, doc = cm.doc;
+    e_preventDefault(e);
+
+    var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges;
+    if (addNew && !e.shiftKey) {
+      ourIndex = doc.sel.contains(start);
+      if (ourIndex > -1)
+        ourRange = ranges[ourIndex];
+      else
+        ourRange = new Range(start, start);
+    } else {
+      ourRange = doc.sel.primary();
+      ourIndex = doc.sel.primIndex;
+    }
+
+    if (e.altKey) {
+      type = "rect";
+      if (!addNew) ourRange = new Range(start, start);
+      start = posFromMouse(cm, e, true, true);
+      ourIndex = -1;
+    } else if (type == "double") {
+      var word = cm.findWordAt(start);
+      if (cm.display.shift || doc.extend)
+        ourRange = extendRange(doc, ourRange, word.anchor, word.head);
+      else
+        ourRange = word;
+    } else if (type == "triple") {
+      var line = new Range(Pos(start.line, 0), clipPos(doc, Pos(start.line + 1, 0)));
+      if (cm.display.shift || doc.extend)
+        ourRange = extendRange(doc, ourRange, line.anchor, line.head);
+      else
+        ourRange = line;
+    } else {
+      ourRange = extendRange(doc, ourRange, start);
+    }
+
+    if (!addNew) {
+      ourIndex = 0;
+      setSelection(doc, new Selection([ourRange], 0), sel_mouse);
+      startSel = doc.sel;
+    } else if (ourIndex == -1) {
+      ourIndex = ranges.length;
+      setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex),
+                   {scroll: false, origin: "*mouse"});
+    } else if (ranges.length > 1 && ranges[ourIndex].empty() && type == "single" && !e.shiftKey) {
+      setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0));
+      startSel = doc.sel;
+    } else {
+      replaceOneSelection(doc, ourIndex, ourRange, sel_mouse);
+    }
+
+    var lastPos = start;
+    function extendTo(pos) {
+      if (cmp(lastPos, pos) == 0) return;
+      lastPos = pos;
+
+      if (type == "rect") {
+        var ranges = [], tabSize = cm.options.tabSize;
+        var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize);
+        var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize);
+        var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol);
+        for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));
+             line <= end; line++) {
+          var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize);
+          if (left == right)
+            ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos)));
+          else if (text.length > leftPos)
+            ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize))));
+        }
+        if (!ranges.length) ranges.push(new Range(start, start));
+        setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),
+                     {origin: "*mouse", scroll: false});
+        cm.scrollIntoView(pos);
+      } else {
+        var oldRange = ourRange;
+        var anchor = oldRange.anchor, head = pos;
+        if (type != "single") {
+          if (type == "double")
+            var range = cm.findWordAt(pos);
+          else
+            var range = new Range(Pos(pos.line, 0), clipPos(doc, Pos(pos.line + 1, 0)));
+          if (cmp(range.anchor, anchor) > 0) {
+            head = range.head;
+            anchor = minPos(oldRange.from(), range.anchor);
+          } else {
+            head = range.anchor;
+            anchor = maxPos(oldRange.to(), range.head);
+          }
+        }
+        var ranges = startSel.ranges.slice(0);
+        ranges[ourIndex] = new Range(clipPos(doc, anchor), head);
+        setSelection(doc, normalizeSelection(ranges, ourIndex), sel_mouse);
+      }
+    }
+
+    var editorSize = display.wrapper.getBoundingClientRect();
+    // Used to ensure timeout re-tries don't fire when another extend
+    // happened in the meantime (clearTimeout isn't reliable -- at
+    // least on Chrome, the timeouts still happen even when cleared,
+    // if the clear happens after their scheduled firing time).
+    var counter = 0;
+
+    function extend(e) {
+      var curCount = ++counter;
+      var cur = posFromMouse(cm, e, true, type == "rect");
+      if (!cur) return;
+      if (cmp(cur, lastPos) != 0) {
+        cm.curOp.focus = activeElt();
+        extendTo(cur);
+        var visible = visibleLines(display, doc);
+        if (cur.line >= visible.to || cur.line < visible.from)
+          setTimeout(operation(cm, function(){if (counter == curCount) extend(e);}), 150);
+      } else {
+        var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0;
+        if (outside) setTimeout(operation(cm, function() {
+          if (counter != curCount) return;
+          display.scroller.scrollTop += outside;
+          extend(e);
+        }), 50);
+      }
+    }
+
+    function done(e) {
+      counter = Infinity;
+      e_preventDefault(e);
+      display.input.focus();
+      off(document, "mousemove", move);
+      off(document, "mouseup", up);
+      doc.history.lastSelOrigin = null;
+    }
+
+    var move = operation(cm, function(e) {
+      if (!e_button(e)) done(e);
+      else extend(e);
+    });
+    var up = operation(cm, done);
+    on(document, "mousemove", move);
+    on(document, "mouseup", up);
+  }
+
+  // Determines whether an event happened in the gutter, and fires the
+  // handlers for the corresponding event.
+  function gutterEvent(cm, e, type, prevent, signalfn) {
+    try { var mX = e.clientX, mY = e.clientY; }
+    catch(e) { return false; }
+    if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) return false;
+    if (prevent) e_preventDefault(e);
+
+    var display = cm.display;
+    var lineBox = display.lineDiv.getBoundingClientRect();
+
+    if (mY > lineBox.bottom || !hasHandler(cm, type)) return e_defaultPrevented(e);
+    mY -= lineBox.top - display.viewOffset;
+
+    for (var i = 0; i < cm.options.gutters.length; ++i) {
+      var g = display.gutters.childNodes[i];
+      if (g && g.getBoundingClientRect().right >= mX) {
+        var line = lineAtHeight(cm.doc, mY);
+        var gutter = cm.options.gutters[i];
+        signalfn(cm, type, cm, line, gutter, e);
+        return e_defaultPrevented(e);
+      }
+    }
+  }
+
+  function clickInGutter(cm, e) {
+    return gutterEvent(cm, e, "gutterClick", true, signalLater);
+  }
+
+  // Kludge to work around strange IE behavior where it'll sometimes
+  // re-fire a series of drag-related events right after the drop (#1551)
+  var lastDrop = 0;
+
+  function onDrop(e) {
+    var cm = this;
+    if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))
+      return;
+    e_preventDefault(e);
+    if (ie) lastDrop = +new Date;
+    var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files;
+    if (!pos || isReadOnly(cm)) return;
+    // Might be a file drop, in which case we simply extract the text
+    // and insert it.
+    if (files && files.length && window.FileReader && window.File) {
+      var n = files.length, text = Array(n), read = 0;
+      var loadFile = function(file, i) {
+        var reader = new FileReader;
+        reader.onload = operation(cm, function() {
+          text[i] = reader.result;
+          if (++read == n) {
+            pos = clipPos(cm.doc, pos);
+            var change = {from: pos, to: pos, text: splitLines(text.join("\n")), origin: "paste"};
+            makeChange(cm.doc, change);
+            setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)));
+          }
+        });
+        reader.readAsText(file);
+      };
+      for (var i = 0; i < n; ++i) loadFile(files[i], i);
+    } else { // Normal drop
+      // Don't do a replace if the drop happened inside of the selected text.
+      if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
+        cm.state.draggingText(e);
+        // Ensure the editor is re-focused
+        setTimeout(function() {cm.display.input.focus();}, 20);
+        return;
+      }
+      try {
+        var text = e.dataTransfer.getData("Text");
+        if (text) {
+          if (cm.state.draggingText && !(mac ? e.altKey : e.ctrlKey))
+            var selected = cm.listSelections();
+          setSelectionNoUndo(cm.doc, simpleSelection(pos, pos));
+          if (selected) for (var i = 0; i < selected.length; ++i)
+            replaceRange(cm.doc, "", selected[i].anchor, selected[i].head, "drag");
+          cm.replaceSelection(text, "around", "paste");
+          cm.display.input.focus();
+        }
+      }
+      catch(e){}
+    }
+  }
+
+  function onDragStart(cm, e) {
+    if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return; }
+    if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) return;
+
+    e.dataTransfer.setData("Text", cm.getSelection());
+
+    // Use dummy image instead of default browsers image.
+    // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
+    if (e.dataTransfer.setDragImage && !safari) {
+      var img = elt("img", null, null, "position: fixed; left: 0; top: 0;");
+      img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
+      if (presto) {
+        img.width = img.height = 1;
+        cm.display.wrapper.appendChild(img);
+        // Force a relayout, or Opera won't use our image for some obscure reason
+        img._top = img.offsetTop;
+      }
+      e.dataTransfer.setDragImage(img, 0, 0);
+      if (presto) img.parentNode.removeChild(img);
+    }
+  }
+
+  // SCROLL EVENTS
+
+  // Sync the scrollable area and scrollbars, ensure the viewport
+  // covers the visible area.
+  function setScrollTop(cm, val) {
+    if (Math.abs(cm.doc.scrollTop - val) < 2) return;
+    cm.doc.scrollTop = val;
+    if (!gecko) updateDisplaySimple(cm, {top: val});
+    if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val;
+    cm.display.scrollbars.setScrollTop(val);
+    if (gecko) updateDisplaySimple(cm);
+    startWorker(cm, 100);
+  }
+  // Sync scroller and scrollbar, ensure the gutter elements are
+  // aligned.
+  function setScrollLeft(cm, val, isScroller) {
+    if (isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) return;
+    val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth);
+    cm.doc.scrollLeft = val;
+    alignHorizontally(cm);
+    if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val;
+    cm.display.scrollbars.setScrollLeft(val);
+  }
+
+  // Since the delta values reported on mouse wheel events are
+  // unstandardized between browsers and even browser versions, and
+  // generally horribly unpredictable, this code starts by measuring
+  // the scroll effect that the first few mouse wheel events have,
+  // and, from that, detects the way it can convert deltas to pixel
+  // offsets afterwards.
+  //
+  // The reason we want to know the amount a wheel event will scroll
+  // is that it gives us a chance to update the display before the
+  // actual scrolling happens, reducing flickering.
+
+  var wheelSamples = 0, wheelPixelsPerUnit = null;
+  // Fill in a browser-detected starting value on browsers where we
+  // know one. These don't have to be accurate -- the result of them
+  // being wrong would just be a slight flicker on the first wheel
+  // scroll (if it is large enough).
+  if (ie) wheelPixelsPerUnit = -.53;
+  else if (gecko) wheelPixelsPerUnit = 15;
+  else if (chrome) wheelPixelsPerUnit = -.7;
+  else if (safari) wheelPixelsPerUnit = -1/3;
+
+  var wheelEventDelta = function(e) {
+    var dx = e.wheelDeltaX, dy = e.wheelDeltaY;
+    if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) dx = e.detail;
+    if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) dy = e.detail;
+    else if (dy == null) dy = e.wheelDelta;
+    return {x: dx, y: dy};
+  };
+  CodeMirror.wheelEventPixels = function(e) {
+    var delta = wheelEventDelta(e);
+    delta.x *= wheelPixelsPerUnit;
+    delta.y *= wheelPixelsPerUnit;
+    return delta;
+  };
+
+  function onScrollWheel(cm, e) {
+    var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y;
+
+    var display = cm.display, scroll = display.scroller;
+    // Quit if there's nothing to scroll here
+    if (!(dx && scroll.scrollWidth > scroll.clientWidth ||
+          dy && scroll.scrollHeight > scroll.clientHeight)) return;
+
+    // Webkit browsers on OS X abort momentum scrolls when the target
+    // of the scroll event is removed from the scrollable element.
+    // This hack (see related code in patchDisplay) makes sure the
+    // element is kept around.
+    if (dy && mac && webkit) {
+      outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {
+        for (var i = 0; i < view.length; i++) {
+          if (view[i].node == cur) {
+            cm.display.currentWheelTarget = cur;
+            break outer;
+          }
+        }
+      }
+    }
+
+    // On some browsers, horizontal scrolling will cause redraws to
+    // happen before the gutter has been realigned, causing it to
+    // wriggle around in a most unseemly way. When we have an
+    // estimated pixels/delta value, we just handle horizontal
+    // scrolling entirely here. It'll be slightly off from native, but
+    // better than glitching out.
+    if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {
+      if (dy)
+        setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight)));
+      setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)));
+      e_preventDefault(e);
+      display.wheelStartX = null; // Abort measurement, if in progress
+      return;
+    }
+
+    // 'Project' the visible viewport to cover the area that is being
+    // scrolled into view (if we know enough to estimate it).
+    if (dy && wheelPixelsPerUnit != null) {
+      var pixels = dy * wheelPixelsPerUnit;
+      var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight;
+      if (pixels < 0) top = Math.max(0, top + pixels - 50);
+      else bot = Math.min(cm.doc.height, bot + pixels + 50);
+      updateDisplaySimple(cm, {top: top, bottom: bot});
+    }
+
+    if (wheelSamples < 20) {
+      if (display.wheelStartX == null) {
+        display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop;
+        display.wheelDX = dx; display.wheelDY = dy;
+        setTimeout(function() {
+          if (display.wheelStartX == null) return;
+          var movedX = scroll.scrollLeft - display.wheelStartX;
+          var movedY = scroll.scrollTop - display.wheelStartY;
+          var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
+            (movedX && display.wheelDX && movedX / display.wheelDX);
+          display.wheelStartX = display.wheelStartY = null;
+          if (!sample) return;
+          wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1);
+          ++wheelSamples;
+        }, 200);
+      } else {
+        display.wheelDX += dx; display.wheelDY += dy;
+      }
+    }
+  }
+
+  // KEY EVENTS
+
+  // Run a handler that was bound to a key.
+  function doHandleBinding(cm, bound, dropShift) {
+    if (typeof bound == "string") {
+      bound = commands[bound];
+      if (!bound) return false;
+    }
+    // Ensure previous input has been read, so that the handler sees a
+    // consistent view of the document
+    cm.display.input.ensurePolled();
+    var prevShift = cm.display.shift, done = false;
+    try {
+      if (isReadOnly(cm)) cm.state.suppressEdits = true;
+      if (dropShift) cm.display.shift = false;
+      done = bound(cm) != Pass;
+    } finally {
+      cm.display.shift = prevShift;
+      cm.state.suppressEdits = false;
+    }
+    return done;
+  }
+
+  function lookupKeyForEditor(cm, name, handle) {
+    for (var i = 0; i < cm.state.keyMaps.length; i++) {
+      var result = lookupKey(name, cm.state.keyMaps[i], handle, cm);
+      if (result) return result;
+    }
+    return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))
+      || lookupKey(name, cm.options.keyMap, handle, cm);
+  }
+
+  var stopSeq = new Delayed;
+  function dispatchKey(cm, name, e, handle) {
+    var seq = cm.state.keySeq;
+    if (seq) {
+      if (isModifierKey(name)) return "handled";
+      stopSeq.set(50, function() {
+        if (cm.state.keySeq == seq) {
+          cm.state.keySeq = null;
+          cm.display.input.reset();
+        }
+      });
+      name = seq + " " + name;
+    }
+    var result = lookupKeyForEditor(cm, name, handle);
+
+    if (result == "multi")
+      cm.state.keySeq = name;
+    if (result == "handled")
+      signalLater(cm, "keyHandled", cm, name, e);
+
+    if (result == "handled" || result == "multi") {
+      e_preventDefault(e);
+      restartBlink(cm);
+    }
+
+    if (seq && !result && /\'$/.test(name)) {
+      e_preventDefault(e);
+      return true;
+    }
+    return !!result;
+  }
+
+  // Handle a key from the keydown event.
+  function handleKeyBinding(cm, e) {
+    var name = keyName(e, true);
+    if (!name) return false;
+
+    if (e.shiftKey && !cm.state.keySeq) {
+      // First try to resolve full name (including 'Shift-'). Failing
+      // that, see if there is a cursor-motion command (starting with
+      // 'go') bound to the keyname without 'Shift-'.
+      return dispatchKey(cm, "Shift-" + name, e, function(b) {return doHandleBinding(cm, b, true);})
+          || dispatchKey(cm, name, e, function(b) {
+               if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion)
+                 return doHandleBinding(cm, b);
+             });
+    } else {
+      return dispatchKey(cm, name, e, function(b) { return doHandleBinding(cm, b); });
+    }
+  }
+
+  // Handle a key from the keypress event
+  function handleCharBinding(cm, e, ch) {
+    return dispatchKey(cm, "'" + ch + "'", e,
+                       function(b) { return doHandleBinding(cm, b, true); });
+  }
+
+  var lastStoppedKey = null;
+  function onKeyDown(e) {
+    var cm = this;
+    cm.curOp.focus = activeElt();
+    if (signalDOMEvent(cm, e)) return;
+    // IE does strange things with escape.
+    if (ie && ie_version < 11 && e.keyCode == 27) e.returnValue = false;
+    var code = e.keyCode;
+    cm.display.shift = code == 16 || e.shiftKey;
+    var handled = handleKeyBinding(cm, e);
+    if (presto) {
+      lastStoppedKey = handled ? code : null;
+      // Opera has no cut event... we try to at least catch the key combo
+      if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))
+        cm.replaceSelection("", null, "cut");
+    }
+
+    // Turn mouse into crosshair when Alt is held on Mac.
+    if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className))
+      showCrossHair(cm);
+  }
+
+  function showCrossHair(cm) {
+    var lineDiv = cm.display.lineDiv;
+    addClass(lineDiv, "CodeMirror-crosshair");
+
+    function up(e) {
+      if (e.keyCode == 18 || !e.altKey) {
+        rmClass(lineDiv, "CodeMirror-crosshair");
+        off(document, "keyup", up);
+        off(document, "mouseover", up);
+      }
+    }
+    on(document, "keyup", up);
+    on(document, "mouseover", up);
+  }
+
+  function onKeyUp(e) {
+    if (e.keyCode == 16) this.doc.sel.shift = false;
+    signalDOMEvent(this, e);
+  }
+
+  function onKeyPress(e) {
+    var cm = this;
+    if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) return;
+    var keyCode = e.keyCode, charCode = e.charCode;
+    if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return;}
+    if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) return;
+    var ch = String.fromCharCode(charCode == null ? keyCode : charCode);
+    if (handleCharBinding(cm, e, ch)) return;
+    cm.display.input.onKeyPress(e);
+  }
+
+  // FOCUS/BLUR EVENTS
+
+  function delayBlurEvent(cm) {
+    cm.state.delayingBlurEvent = true;
+    setTimeout(function() {
+      if (cm.state.delayingBlurEvent) {
+        cm.state.delayingBlurEvent = false;
+        onBlur(cm);
+      }
+    }, 100);
+  }
+
+  function onFocus(cm) {
+    if (cm.state.delayingBlurEvent) cm.state.delayingBlurEvent = false;
+
+    if (cm.options.readOnly == "nocursor") return;
+    if (!cm.state.focused) {
+      signal(cm, "focus", cm);
+      cm.state.focused = true;
+      addClass(cm.display.wrapper, "CodeMirror-focused");
+      // This test prevents this from firing when a context
+      // menu is closed (since the input reset would kill the
+      // select-all detection hack)
+      if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {
+        cm.display.input.reset();
+        if (webkit) setTimeout(function() { cm.display.input.reset(true); }, 20); // Issue #1730
+      }
+      cm.display.input.receivedFocus();
+    }
+    restartBlink(cm);
+  }
+  function onBlur(cm) {
+    if (cm.state.delayingBlurEvent) return;
+
+    if (cm.state.focused) {
+      signal(cm, "blur", cm);
+      cm.state.focused = false;
+      rmClass(cm.display.wrapper, "CodeMirror-focused");
+    }
+    clearInterval(cm.display.blinker);
+    setTimeout(function() {if (!cm.state.focused) cm.display.shift = false;}, 150);
+  }
+
+  // CONTEXT MENU HANDLING
+
+  // To make the context menu work, we need to briefly unhide the
+  // textarea (making it as unobtrusive as possible) to let the
+  // right-click take effect on it.
+  function onContextMenu(cm, e) {
+    if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) return;
+    cm.display.input.onContextMenu(e);
+  }
+
+  function contextMenuInGutter(cm, e) {
+    if (!hasHandler(cm, "gutterContextMenu")) return false;
+    return gutterEvent(cm, e, "gutterContextMenu", false, signal);
+  }
+
+  // UPDATING
+
+  // Compute the position of the end of a change (its 'to' property
+  // refers to the pre-change end).
+  var changeEnd = CodeMirror.changeEnd = function(change) {
+    if (!change.text) return change.to;
+    return Pos(change.from.line + change.text.length - 1,
+               lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0));
+  };
+
+  // Adjust a position to refer to the post-change position of the
+  // same text, or the end of the change if the change covers it.
+  function adjustForChange(pos, change) {
+    if (cmp(pos, change.from) < 0) return pos;
+    if (cmp(pos, change.to) <= 0) return changeEnd(change);
+
+    var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch;
+    if (pos.line == change.to.line) ch += changeEnd(change).ch - change.to.ch;
+    return Pos(line, ch);
+  }
+
+  function computeSelAfterChange(doc, change) {
+    var out = [];
+    for (var i = 0; i < doc.sel.ranges.length; i++) {
+      var range = doc.sel.ranges[i];
+      out.push(new Range(adjustForChange(range.anchor, change),
+                         adjustForChange(range.head, change)));
+    }
+    return normalizeSelection(out, doc.sel.primIndex);
+  }
+
+  function offsetPos(pos, old, nw) {
+    if (pos.line == old.line)
+      return Pos(nw.line, pos.ch - old.ch + nw.ch);
+    else
+      return Pos(nw.line + (pos.line - old.line), pos.ch);
+  }
+
+  // Used by replaceSelections to allow moving the selection to the
+  // start or around the replaced test. Hint may be "start" or "around".
+  function computeReplacedSel(doc, changes, hint) {
+    var out = [];
+    var oldPrev = Pos(doc.first, 0), newPrev = oldPrev;
+    for (var i = 0; i < changes.length; i++) {
+      var change = changes[i];
+      var from = offsetPos(change.from, oldPrev, newPrev);
+      var to = offsetPos(changeEnd(change), oldPrev, newPrev);
+      oldPrev = change.to;
+      newPrev = to;
+      if (hint == "around") {
+        var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0;
+        out[i] = new Range(inv ? to : from, inv ? from : to);
+      } else {
+        out[i] = new Range(from, from);
+      }
+    }
+    return new Selection(out, doc.sel.primIndex);
+  }
+
+  // Allow "beforeChange" event handlers to influence a change
+  function filterChange(doc, change, update) {
+    var obj = {
+      canceled: false,
+      from: change.from,
+      to: change.to,
+      text: change.text,
+      origin: change.origin,
+      cancel: function() { this.canceled = true; }
+    };
+    if (update) obj.update = function(from, to, text, origin) {
+      if (from) this.from = clipPos(doc, from);
+      if (to) this.to = clipPos(doc, to);
+      if (text) this.text = text;
+      if (origin !== undefined) this.origin = origin;
+    };
+    signal(doc, "beforeChange", doc, obj);
+    if (doc.cm) signal(doc.cm, "beforeChange", doc.cm, obj);
+
+    if (obj.canceled) return null;
+    return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin};
+  }
+
+  // Apply a change to a document, and add it to the document's
+  // history, and propagating it to all linked documents.
+  function makeChange(doc, change, ignoreReadOnly) {
+    if (doc.cm) {
+      if (!doc.cm.curOp) return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly);
+      if (doc.cm.state.suppressEdits) return;
+    }
+
+    if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
+      change = filterChange(doc, change, true);
+      if (!change) return;
+    }
+
+    // Possibly split or suppress the update based on the presence
+    // of read-only spans in its range.
+    var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to);
+    if (split) {
+      for (var i = split.length - 1; i >= 0; --i)
+        makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text});
+    } else {
+      makeChangeInner(doc, change);
+    }
+  }
+
+  function makeChangeInner(doc, change) {
+    if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) return;
+    var selAfter = computeSelAfterChange(doc, change);
+    addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN);
+
+    makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change));
+    var rebased = [];
+
+    linkedDocs(doc, function(doc, sharedHist) {
+      if (!sharedHist && indexOf(rebased, doc.history) == -1) {
+        rebaseHist(doc.history, change);
+        rebased.push(doc.history);
+      }
+      makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change));
+    });
+  }
+
+  // Revert a change stored in a document's history.
+  function makeChangeFromHistory(doc, type, allowSelectionOnly) {
+    if (doc.cm && doc.cm.state.suppressEdits) return;
+
+    var hist = doc.history, event, selAfter = doc.sel;
+    var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done;
+
+    // Verify that there is a useable event (so that ctrl-z won't
+    // needlessly clear selection events)
+    for (var i = 0; i < source.length; i++) {
+      event = source[i];
+      if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
+        break;
+    }
+    if (i == source.length) return;
+    hist.lastOrigin = hist.lastSelOrigin = null;
+
+    for (;;) {
+      event = source.pop();
+      if (event.ranges) {
+        pushSelectionToHistory(event, dest);
+        if (allowSelectionOnly && !event.equals(doc.sel)) {
+          setSelection(doc, event, {clearRedo: false});
+          return;
+        }
+        selAfter = event;
+      }
+      else break;
+    }
+
+    // Build up a reverse change object to add to the opposite history
+    // stack (redo when undoing, and vice versa).
+    var antiChanges = [];
+    pushSelectionToHistory(selAfter, dest);
+    dest.push({changes: antiChanges, generation: hist.generation});
+    hist.generation = event.generation || ++hist.maxGeneration;
+
+    var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange");
+
+    for (var i = event.changes.length - 1; i >= 0; --i) {
+      var change = event.changes[i];
+      change.origin = type;
+      if (filter && !filterChange(doc, change, false)) {
+        source.length = 0;
+        return;
+      }
+
+      antiChanges.push(historyChangeFromChange(doc, change));
+
+      var after = i ? computeSelAfterChange(doc, change) : lst(source);
+      makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change));
+      if (!i && doc.cm) doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)});
+      var rebased = [];
+
+      // Propagate to the linked documents
+      linkedDocs(doc, function(doc, sharedHist) {
+        if (!sharedHist && indexOf(rebased, doc.history) == -1) {
+          rebaseHist(doc.history, change);
+          rebased.push(doc.history);
+        }
+        makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change));
+      });
+    }
+  }
+
+  // Sub-views need their line numbers shifted when text is added
+  // above or below them in the parent document.
+  function shiftDoc(doc, distance) {
+    if (distance == 0) return;
+    doc.first += distance;
+    doc.sel = new Selection(map(doc.sel.ranges, function(range) {
+      return new Range(Pos(range.anchor.line + distance, range.anchor.ch),
+                       Pos(range.head.line + distance, range.head.ch));
+    }), doc.sel.primIndex);
+    if (doc.cm) {
+      regChange(doc.cm, doc.first, doc.first - distance, distance);
+      for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
+        regLineChange(doc.cm, l, "gutter");
+    }
+  }
+
+  // More lower-level change function, handling only a single document
+  // (not linked ones).
+  function makeChangeSingleDoc(doc, change, selAfter, spans) {
+    if (doc.cm && !doc.cm.curOp)
+      return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans);
+
+    if (change.to.line < doc.first) {
+      shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line));
+      return;
+    }
+    if (change.from.line > doc.lastLine()) return;
+
+    // Clip the change to the size of this doc
+    if (change.from.line < doc.first) {
+      var shift = change.text.length - 1 - (doc.first - change.from.line);
+      shiftDoc(doc, shift);
+      change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
+                text: [lst(change.text)], origin: change.origin};
+    }
+    var last = doc.lastLine();
+    if (change.to.line > last) {
+      change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
+                text: [change.text[0]], origin: change.origin};
+    }
+
+    change.removed = getBetween(doc, change.from, change.to);
+
+    if (!selAfter) selAfter = computeSelAfterChange(doc, change);
+    if (doc.cm) makeChangeSingleDocInEditor(doc.cm, change, spans);
+    else updateDoc(doc, change, spans);
+    setSelectionNoUndo(doc, selAfter, sel_dontScroll);
+  }
+
+  // Handle the interaction of a change to a document with the editor
+  // that this document is part of.
+  function makeChangeSingleDocInEditor(cm, change, spans) {
+    var doc = cm.doc, display = cm.display, from = change.from, to = change.to;
+
+    var recomputeMaxLength = false, checkWidthStart = from.line;
+    if (!cm.options.lineWrapping) {
+      checkWidthStart = lineNo(visualLine(getLine(doc, from.line)));
+      doc.iter(checkWidthStart, to.line + 1, function(line) {
+        if (line == display.maxLine) {
+          recomputeMaxLength = true;
+          return true;
+        }
+      });
+    }
+
+    if (doc.sel.contains(change.from, change.to) > -1)
+      signalCursorActivity(cm);
+
+    updateDoc(doc, change, spans, estimateHeight(cm));
+
+    if (!cm.options.lineWrapping) {
+      doc.iter(checkWidthStart, from.line + change.text.length, function(line) {
+        var len = lineLength(line);
+        if (len > display.maxLineLength) {
+          display.maxLine = line;
+          display.maxLineLength = len;
+          display.maxLineChanged = true;
+          recomputeMaxLength = false;
+        }
+      });
+      if (recomputeMaxLength) cm.curOp.updateMaxLine = true;
+    }
+
+    // Adjust frontier, schedule worker
+    doc.frontier = Math.min(doc.frontier, from.line);
+    startWorker(cm, 400);
+
+    var lendiff = change.text.length - (to.line - from.line) - 1;
+    // Remember that these lines changed, for updating the display
+    if (change.full)
+      regChange(cm);
+    else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
+      regLineChange(cm, from.line, "text");
+    else
+      regChange(cm, from.line, to.line + 1, lendiff);
+
+    var changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change");
+    if (changeHandler || changesHandler) {
+      var obj = {
+        from: from, to: to,
+        text: change.text,
+        removed: change.removed,
+        origin: change.origin
+      };
+      if (changeHandler) signalLater(cm, "change", cm, obj);
+      if (changesHandler) (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj);
+    }
+    cm.display.selForContextMenu = null;
+  }
+
+  function replaceRange(doc, code, from, to, origin) {
+    if (!to) to = from;
+    if (cmp(to, from) < 0) { var tmp = to; to = from; from = tmp; }
+    if (typeof code == "string") code = splitLines(code);
+    makeChange(doc, {from: from, to: to, text: code, origin: origin});
+  }
+
+  // SCROLLING THINGS INTO VIEW
+
+  // If an editor sits on the top or bottom of the window, partially
+  // scrolled out of view, this ensures that the cursor is visible.
+  function maybeScrollWindow(cm, coords) {
+    if (signalDOMEvent(cm, "scrollCursorIntoView")) return;
+
+    var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null;
+    if (coords.top + box.top < 0) doScroll = true;
+    else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) doScroll = false;
+    if (doScroll != null && !phantom) {
+      var scrollNode = elt("div", "\u200b", null, "position: absolute; top: " +
+                           (coords.top - display.viewOffset - paddingTop(cm.display)) + "px; height: " +
+                           (coords.bottom - coords.top + scrollGap(cm) + display.barHeight) + "px; left: " +
+                           coords.left + "px; width: 2px;");
+      cm.display.lineSpace.appendChild(scrollNode);
+      scrollNode.scrollIntoView(doScroll);
+      cm.display.lineSpace.removeChild(scrollNode);
+    }
+  }
+
+  // Scroll a given position into view (immediately), verifying that
+  // it actually became visible (as line heights are accurately
+  // measured, the position of something may 'drift' during drawing).
+  function scrollPosIntoView(cm, pos, end, margin) {
+    if (margin == null) margin = 0;
+    for (var limit = 0; limit < 5; limit++) {
+      var changed = false, coords = cursorCoords(cm, pos);
+      var endCoords = !end || end == pos ? coords : cursorCoords(cm, end);
+      var scrollPos = calculateScrollPos(cm, Math.min(coords.left, endCoords.left),
+                                         Math.min(coords.top, endCoords.top) - margin,
+                                         Math.max(coords.left, endCoords.left),
+                                         Math.max(coords.bottom, endCoords.bottom) + margin);
+      var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft;
+      if (scrollPos.scrollTop != null) {
+        setScrollTop(cm, scrollPos.scrollTop);
+        if (Math.abs(cm.doc.scrollTop - startTop) > 1) changed = true;
+      }
+      if (scrollPos.scrollLeft != null) {
+        setScrollLeft(cm, scrollPos.scrollLeft);
+        if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) changed = true;
+      }
+      if (!changed) break;
+    }
+    return coords;
+  }
+
+  // Scroll a given set of coordinates into view (immediately).
+  function scrollIntoView(cm, x1, y1, x2, y2) {
+    var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2);
+    if (scrollPos.scrollTop != null) setScrollTop(cm, scrollPos.scrollTop);
+    if (scrollPos.scrollLeft != null) setScrollLeft(cm, scrollPos.scrollLeft);
+  }
+
+  // Calculate a new scroll position needed to scroll the given
+  // rectangle into view. Returns an object with scrollTop and
+  // scrollLeft properties. When these are undefined, the
+  // vertical/horizontal position does not need to be adjusted.
+  function calculateScrollPos(cm, x1, y1, x2, y2) {
+    var display = cm.display, snapMargin = textHeight(cm.display);
+    if (y1 < 0) y1 = 0;
+    var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop;
+    var screen = displayHeight(cm), result = {};
+    if (y2 - y1 > screen) y2 = y1 + screen;
+    var docBottom = cm.doc.height + paddingVert(display);
+    var atTop = y1 < snapMargin, atBottom = y2 > docBottom - snapMargin;
+    if (y1 < screentop) {
+      result.scrollTop = atTop ? 0 : y1;
+    } else if (y2 > screentop + screen) {
+      var newTop = Math.min(y1, (atBottom ? docBottom : y2) - screen);
+      if (newTop != screentop) result.scrollTop = newTop;
+    }
+
+    var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft;
+    var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0);
+    var tooWide = x2 - x1 > screenw;
+    if (tooWide) x2 = x1 + screenw;
+    if (x1 < 10)
+      result.scrollLeft = 0;
+    else if (x1 < screenleft)
+      result.scrollLeft = Math.max(0, x1 - (tooWide ? 0 : 10));
+    else if (x2 > screenw + screenleft - 3)
+      result.scrollLeft = x2 + (tooWide ? 0 : 10) - screenw;
+    return result;
+  }
+
+  // Store a relative adjustment to the scroll position in the current
+  // operation (to be applied when the operation finishes).
+  function addToScrollPos(cm, left, top) {
+    if (left != null || top != null) resolveScrollToPos(cm);
+    if (left != null)
+      cm.curOp.scrollLeft = (cm.curOp.scrollLeft == null ? cm.doc.scrollLeft : cm.curOp.scrollLeft) + left;
+    if (top != null)
+      cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top;
+  }
+
+  // Make sure that at the end of the operation the current cursor is
+  // shown.
+  function ensureCursorVisible(cm) {
+    resolveScrollToPos(cm);
+    var cur = cm.getCursor(), from = cur, to = cur;
+    if (!cm.options.lineWrapping) {
+      from = cur.ch ? Pos(cur.line, cur.ch - 1) : cur;
+      to = Pos(cur.line, cur.ch + 1);
+    }
+    cm.curOp.scrollToPos = {from: from, to: to, margin: cm.options.cursorScrollMargin, isCursor: true};
+  }
+
+  // When an operation has its scrollToPos property set, and another
+  // scroll action is applied before the end of the operation, this
+  // 'simulates' scrolling that position into view in a cheap way, so
+  // that the effect of intermediate scroll commands is not ignored.
+  function resolveScrollToPos(cm) {
+    var range = cm.curOp.scrollToPos;
+    if (range) {
+      cm.curOp.scrollToPos = null;
+      var from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to);
+      var sPos = calculateScrollPos(cm, Math.min(from.left, to.left),
+                                    Math.min(from.top, to.top) - range.margin,
+                                    Math.max(from.right, to.right),
+                                    Math.max(from.bottom, to.bottom) + range.margin);
+      cm.scrollTo(sPos.scrollLeft, sPos.scrollTop);
+    }
+  }
+
+  // API UTILITIES
+
+  // Indent the given line. The how parameter can be "smart",
+  // "add"/null, "subtract", or "prev". When aggressive is false
+  // (typically set to true for forced single-line indents), empty
+  // lines are not indented, and places where the mode returns Pass
+  // are left alone.
+  function indentLine(cm, n, how, aggressive) {
+    var doc = cm.doc, state;
+    if (how == null) how = "add";
+    if (how == "smart") {
+      // Fall back to "prev" when the mode doesn't have an indentation
+      // method.
+      if (!doc.mode.indent) how = "prev";
+      else state = getStateBefore(cm, n);
+    }
+
+    var tabSize = cm.options.tabSize;
+    var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize);
+    if (line.stateAfter) line.stateAfter = null;
+    var curSpaceString = line.text.match(/^\s*/)[0], indentation;
+    if (!aggressive && !/\S/.test(line.text)) {
+      indentation = 0;
+      how = "not";
+    } else if (how == "smart") {
+      indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text);
+      if (indentation == Pass || indentation > 150) {
+        if (!aggressive) return;
+        how = "prev";
+      }
+    }
+    if (how == "prev") {
+      if (n > doc.first) indentation = countColumn(getLine(doc, n-1).text, null, tabSize);
+      else indentation = 0;
+    } else if (how == "add") {
+      indentation = curSpace + cm.options.indentUnit;
+    } else if (how == "subtract") {
+      indentation = curSpace - cm.options.indentUnit;
+    } else if (typeof how == "number") {
+      indentation = curSpace + how;
+    }
+    indentation = Math.max(0, indentation);
+
+    var indentString = "", pos = 0;
+    if (cm.options.indentWithTabs)
+      for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";}
+    if (pos < indentation) indentString += spaceStr(indentation - pos);
+
+    if (indentString != curSpaceString) {
+      replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input");
+      line.stateAfter = null;
+      return true;
+    } else {
+      // Ensure that, if the cursor was in the whitespace at the start
+      // of the line, it is moved to the end of that space.
+      for (var i = 0; i < doc.sel.ranges.length; i++) {
+        var range = doc.sel.ranges[i];
+        if (range.head.line == n && range.head.ch < curSpaceString.length) {
+          var pos = Pos(n, curSpaceString.length);
+          replaceOneSelection(doc, i, new Range(pos, pos));
+          break;
+        }
+      }
+    }
+  }
+
+  // Utility for applying a change to a line by handle or number,
+  // returning the number and optionally registering the line as
+  // changed.
+  function changeLine(doc, handle, changeType, op) {
+    var no = handle, line = handle;
+    if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle));
+    else no = lineNo(handle);
+    if (no == null) return null;
+    if (op(line, no) && doc.cm) regLineChange(doc.cm, no, changeType);
+    return line;
+  }
+
+  // Helper for deleting text near the selection(s), used to implement
+  // backspace, delete, and similar functionality.
+  function deleteNearSelection(cm, compute) {
+    var ranges = cm.doc.sel.ranges, kill = [];
+    // Build up a set of ranges to kill first, merging overlapping
+    // ranges.
+    for (var i = 0; i < ranges.length; i++) {
+      var toKill = compute(ranges[i]);
+      while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
+        var replaced = kill.pop();
+        if (cmp(replaced.from, toKill.from) < 0) {
+          toKill.from = replaced.from;
+          break;
+        }
+      }
+      kill.push(toKill);
+    }
+    // Next, remove those actual ranges.
+    runInOp(cm, function() {
+      for (var i = kill.length - 1; i >= 0; i--)
+        replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete");
+      ensureCursorVisible(cm);
+    });
+  }
+
+  // Used for horizontal relative motion. Dir is -1 or 1 (left or
+  // right), unit can be "char", "column" (like char, but doesn't
+  // cross line boundaries), "word" (across next word), or "group" (to
+  // the start of next group of word or non-word-non-whitespace
+  // chars). The visually param controls whether, in right-to-left
+  // text, direction 1 means to move towards the next index in the
+  // string, or towards the character to the right of the current
+  // position. The resulting position will have a hitSide=true
+  // property if it reached the end of the document.
+  function findPosH(doc, pos, dir, unit, visually) {
+    var line = pos.line, ch = pos.ch, origDir = dir;
+    var lineObj = getLine(doc, line);
+    var possible = true;
+    function findNextLine() {
+      var l = line + dir;
+      if (l < doc.first || l >= doc.first + doc.size) return (possible = false);
+      line = l;
+      return lineObj = getLine(doc, l);
+    }
+    function moveOnce(boundToLine) {
+      var next = (visually ? moveVisually : moveLogically)(lineObj, ch, dir, true);
+      if (next == null) {
+        if (!boundToLine && findNextLine()) {
+          if (visually) ch = (dir < 0 ? lineRight : lineLeft)(lineObj);
+          else ch = dir < 0 ? lineObj.text.length : 0;
+        } else return (possible = false);
+      } else ch = next;
+      return true;
+    }
+
+    if (unit == "char") moveOnce();
+    else if (unit == "column") moveOnce(true);
+    else if (unit == "word" || unit == "group") {
+      var sawType = null, group = unit == "group";
+      var helper = doc.cm && doc.cm.getHelper(pos, "wordChars");
+      for (var first = true;; first = false) {
+        if (dir < 0 && !moveOnce(!first)) break;
+        var cur = lineObj.text.charAt(ch) || "\n";
+        var type = isWordChar(cur, helper) ? "w"
+          : group && cur == "\n" ? "n"
+          : !group || /\s/.test(cur) ? null
+          : "p";
+        if (group && !first && !type) type = "s";
+        if (sawType && sawType != type) {
+          if (dir < 0) {dir = 1; moveOnce();}
+          break;
+        }
+
+        if (type) sawType = type;
+        if (dir > 0 && !moveOnce(!first)) break;
+      }
+    }
+    var result = skipAtomic(doc, Pos(line, ch), origDir, true);
+    if (!possible) result.hitSide = true;
+    return result;
+  }
+
+  // For relative vertical movement. Dir may be -1 or 1. Unit can be
+  // "page" or "line". The resulting position will have a hitSide=true
+  // property if it reached the end of the document.
+  function findPosV(cm, pos, dir, unit) {
+    var doc = cm.doc, x = pos.left, y;
+    if (unit == "page") {
+      var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight);
+      y = pos.top + dir * (pageSize - (dir < 0 ? 1.5 : .5) * textHeight(cm.display));
+    } else if (unit == "line") {
+      y = dir > 0 ? pos.bottom + 3 : pos.top - 3;
+    }
+    for (;;) {
+      var target = coordsChar(cm, x, y);
+      if (!target.outside) break;
+      if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break; }
+      y += dir * 5;
+    }
+    return target;
+  }
+
+  // EDITOR METHODS
+
+  // The publicly visible API. Note that methodOp(f) means
+  // 'wrap f in an operation, performed on its `this` parameter'.
+
+  // This is not the complete set of editor methods. Most of the
+  // methods defined on the Doc type are also injected into
+  // CodeMirror.prototype, for backwards compatibility and
+  // convenience.
+
+  CodeMirror.prototype = {
+    constructor: CodeMirror,
+    focus: function(){window.focus(); this.display.input.focus();},
+
+    setOption: function(option, value) {
+      var options = this.options, old = options[option];
+      if (options[option] == value && option != "mode") return;
+      options[option] = value;
+      if (optionHandlers.hasOwnProperty(option))
+        operation(this, optionHandlers[option])(this, value, old);
+    },
+
+    getOption: function(option) {return this.options[option];},
+    getDoc: function() {return this.doc;},
+
+    addKeyMap: function(map, bottom) {
+      this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map));
+    },
+    removeKeyMap: function(map) {
+      var maps = this.state.keyMaps;
+      for (var i = 0; i < maps.length; ++i)
+        if (maps[i] == map || maps[i].name == map) {
+          maps.splice(i, 1);
+          return true;
+        }
+    },
+
+    addOverlay: methodOp(function(spec, options) {
+      var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec);
+      if (mode.startState) throw new Error("Overlays may not be stateful.");
+      this.state.overlays.push({mode: mode, modeSpec: spec, opaque: options && options.opaque});
+      this.state.modeGen++;
+      regChange(this);
+    }),
+    removeOverlay: methodOp(function(spec) {
+      var overlays = this.state.overlays;
+      for (var i = 0; i < overlays.length; ++i) {
+        var cur = overlays[i].modeSpec;
+        if (cur == spec || typeof spec == "string" && cur.name == spec) {
+          overlays.splice(i, 1);
+          this.state.modeGen++;
+          regChange(this);
+          return;
+        }
+      }
+    }),
+
+    indentLine: methodOp(function(n, dir, aggressive) {
+      if (typeof dir != "string" && typeof dir != "number") {
+        if (dir == null) dir = this.options.smartIndent ? "smart" : "prev";
+        else dir = dir ? "add" : "subtract";
+      }
+      if (isLine(this.doc, n)) indentLine(this, n, dir, aggressive);
+    }),
+    indentSelection: methodOp(function(how) {
+      var ranges = this.doc.sel.ranges, end = -1;
+      for (var i = 0; i < ranges.length; i++) {
+        var range = ranges[i];
+        if (!range.empty()) {
+          var from = range.from(), to = range.to();
+          var start = Math.max(end, from.line);
+          end = Math.min(this.lastLine(), to.line - (to.ch ? 0 : 1)) + 1;
+          for (var j = start; j < end; ++j)
+            indentLine(this, j, how);
+          var newRanges = this.doc.sel.ranges;
+          if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)
+            replaceOneSelection(this.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll);
+        } else if (range.head.line > end) {
+          indentLine(this, range.head.line, how, true);
+          end = range.head.line;
+          if (i == this.doc.sel.primIndex) ensureCursorVisible(this);
+        }
+      }
+    }),
+
+    // Fetch the parser token for a given character. Useful for hacks
+    // that want to inspect the mode state (say, for completion).
+    getTokenAt: function(pos, precise) {
+      return takeToken(this, pos, precise);
+    },
+
+    getLineTokens: function(line, precise) {
+      return takeToken(this, Pos(line), precise, true);
+    },
+
+    getTokenTypeAt: function(pos) {
+      pos = clipPos(this.doc, pos);
+      var styles = getLineStyles(this, getLine(this.doc, pos.line));
+      var before = 0, after = (styles.length - 1) / 2, ch = pos.ch;
+      var type;
+      if (ch == 0) type = styles[2];
+      else for (;;) {
+        var mid = (before + after) >> 1;
+        if ((mid ? styles[mid * 2 - 1] : 0) >= ch) after = mid;
+        else if (styles[mid * 2 + 1] < ch) before = mid + 1;
+        else { type = styles[mid * 2 + 2]; break; }
+      }
+      var cut = type ? type.indexOf("cm-overlay ") : -1;
+      return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1);
+    },
+
+    getModeAt: function(pos) {
+      var mode = this.doc.mode;
+      if (!mode.innerMode) return mode;
+      return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode;
+    },
+
+    getHelper: function(pos, type) {
+      return this.getHelpers(pos, type)[0];
+    },
+
+    getHelpers: function(pos, type) {
+      var found = [];
+      if (!helpers.hasOwnProperty(type)) return found;
+      var help = helpers[type], mode = this.getModeAt(pos);
+      if (typeof mode[type] == "string") {
+        if (help[mode[type]]) found.push(help[mode[type]]);
+      } else if (mode[type]) {
+        for (var i = 0; i < mode[type].length; i++) {
+          var val = help[mode[type][i]];
+          if (val) found.push(val);
+        }
+      } else if (mode.helperType && help[mode.helperType]) {
+        found.push(help[mode.helperType]);
+      } else if (help[mode.name]) {
+        found.push(help[mode.name]);
+      }
+      for (var i = 0; i < help._global.length; i++) {
+        var cur = help._global[i];
+        if (cur.pred(mode, this) && indexOf(found, cur.val) == -1)
+          found.push(cur.val);
+      }
+      return found;
+    },
+
+    getStateAfter: function(line, precise) {
+      var doc = this.doc;
+      line = clipLine(doc, line == null ? doc.first + doc.size - 1: line);
+      return getStateBefore(this, line + 1, precise);
+    },
+
+    cursorCoords: function(start, mode) {
+      var pos, range = this.doc.sel.primary();
+      if (start == null) pos = range.head;
+      else if (typeof start == "object") pos = clipPos(this.doc, start);
+      else pos = start ? range.from() : range.to();
+      return cursorCoords(this, pos, mode || "page");
+    },
+
+    charCoords: function(pos, mode) {
+      return charCoords(this, clipPos(this.doc, pos), mode || "page");
+    },
+
+    coordsChar: function(coords, mode) {
+      coords = fromCoordSystem(this, coords, mode || "page");
+      return coordsChar(this, coords.left, coords.top);
+    },
+
+    lineAtHeight: function(height, mode) {
+      height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top;
+      return lineAtHeight(this.doc, height + this.display.viewOffset);
+    },
+    heightAtLine: function(line, mode) {
+      var end = false, lineObj;
+      if (typeof line == "number") {
+        var last = this.doc.first + this.doc.size - 1;
+        if (line < this.doc.first) line = this.doc.first;
+        else if (line > last) { line = last; end = true; }
+        lineObj = getLine(this.doc, line);
+      } else {
+        lineObj = line;
+      }
+      return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page").top +
+        (end ? this.doc.height - heightAtLine(lineObj) : 0);
+    },
+
+    defaultTextHeight: function() { return textHeight(this.display); },
+    defaultCharWidth: function() { return charWidth(this.display); },
+
+    setGutterMarker: methodOp(function(line, gutterID, value) {
+      return changeLine(this.doc, line, "gutter", function(line) {
+        var markers = line.gutterMarkers || (line.gutterMarkers = {});
+        markers[gutterID] = value;
+        if (!value && isEmpty(markers)) line.gutterMarkers = null;
+        return true;
+      });
+    }),
+
+    clearGutter: methodOp(function(gutterID) {
+      var cm = this, doc = cm.doc, i = doc.first;
+      doc.iter(function(line) {
+        if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
+          line.gutterMarkers[gutterID] = null;
+          regLineChange(cm, i, "gutter");
+          if (isEmpty(line.gutterMarkers)) line.gutterMarkers = null;
+        }
+        ++i;
+      });
+    }),
+
+    lineInfo: function(line) {
+      if (typeof line == "number") {
+        if (!isLine(this.doc, line)) return null;
+        var n = line;
+        line = getLine(this.doc, line);
+        if (!line) return null;
+      } else {
+        var n = lineNo(line);
+        if (n == null) return null;
+      }
+      return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
+              textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
+              widgets: line.widgets};
+    },
+
+    getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo};},
+
+    addWidget: function(pos, node, scroll, vert, horiz) {
+      var display = this.display;
+      pos = cursorCoords(this, clipPos(this.doc, pos));
+      var top = pos.bottom, left = pos.left;
+      node.style.position = "absolute";
+      node.setAttribute("cm-ignore-events", "true");
+      this.display.input.setUneditable(node);
+      display.sizer.appendChild(node);
+      if (vert == "over") {
+        top = pos.top;
+      } else if (vert == "above" || vert == "near") {
+        var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),
+        hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth);
+        // Default to positioning above (if specified and possible); otherwise default to positioning below
+        if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)
+          top = pos.top - node.offsetHeight;
+        else if (pos.bottom + node.offsetHeight <= vspace)
+          top = pos.bottom;
+        if (left + node.offsetWidth > hspace)
+          left = hspace - node.offsetWidth;
+      }
+      node.style.top = top + "px";
+      node.style.left = node.style.right = "";
+      if (horiz == "right") {
+        left = display.sizer.clientWidth - node.offsetWidth;
+        node.style.right = "0px";
+      } else {
+        if (horiz == "left") left = 0;
+        else if (horiz == "middle") left = (display.sizer.clientWidth - node.offsetWidth) / 2;
+        node.style.left = left + "px";
+      }
+      if (scroll)
+        scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight);
+    },
+
+    triggerOnKeyDown: methodOp(onKeyDown),
+    triggerOnKeyPress: methodOp(onKeyPress),
+    triggerOnKeyUp: onKeyUp,
+
+    execCommand: function(cmd) {
+      if (commands.hasOwnProperty(cmd))
+        return commands[cmd](this);
+    },
+
+    triggerElectric: methodOp(function(text) { triggerElectric(this, text); }),
+
+    findPosH: function(from, amount, unit, visually) {
+      var dir = 1;
+      if (amount < 0) { dir = -1; amount = -amount; }
+      for (var i = 0, cur = clipPos(this.doc, from); i < amount; ++i) {
+        cur = findPosH(this.doc, cur, dir, unit, visually);
+        if (cur.hitSide) break;
+      }
+      return cur;
+    },
+
+    moveH: methodOp(function(dir, unit) {
+      var cm = this;
+      cm.extendSelectionsBy(function(range) {
+        if (cm.display.shift || cm.doc.extend || range.empty())
+          return findPosH(cm.doc, range.head, dir, unit, cm.options.rtlMoveVisually);
+        else
+          return dir < 0 ? range.from() : range.to();
+      }, sel_move);
+    }),
+
+    deleteH: methodOp(function(dir, unit) {
+      var sel = this.doc.sel, doc = this.doc;
+      if (sel.somethingSelected())
+        doc.replaceSelection("", null, "+delete");
+      else
+        deleteNearSelection(this, function(range) {
+          var other = findPosH(doc, range.head, dir, unit, false);
+          return dir < 0 ? {from: other, to: range.head} : {from: range.head, to: other};
+        });
+    }),
+
+    findPosV: function(from, amount, unit, goalColumn) {
+      var dir = 1, x = goalColumn;
+      if (amount < 0) { dir = -1; amount = -amount; }
+      for (var i = 0, cur = clipPos(this.doc, from); i < amount; ++i) {
+        var coords = cursorCoords(this, cur, "div");
+        if (x == null) x = coords.left;
+        else coords.left = x;
+        cur = findPosV(this, coords, dir, unit);
+        if (cur.hitSide) break;
+      }
+      return cur;
+    },
+
+    moveV: methodOp(function(dir, unit) {
+      var cm = this, doc = this.doc, goals = [];
+      var collapse = !cm.display.shift && !doc.extend && doc.sel.somethingSelected();
+      doc.extendSelectionsBy(function(range) {
+        if (collapse)
+          return dir < 0 ? range.from() : range.to();
+        var headPos = cursorCoords(cm, range.head, "div");
+        if (range.goalColumn != null) headPos.left = range.goalColumn;
+        goals.push(headPos.left);
+        var pos = findPosV(cm, headPos, dir, unit);
+        if (unit == "page" && range == doc.sel.primary())
+          addToScrollPos(cm, null, charCoords(cm, pos, "div").top - headPos.top);
+        return pos;
+      }, sel_move);
+      if (goals.length) for (var i = 0; i < doc.sel.ranges.length; i++)
+        doc.sel.ranges[i].goalColumn = goals[i];
+    }),
+
+    // Find the word at the given position (as returned by coordsChar).
+    findWordAt: function(pos) {
+      var doc = this.doc, line = getLine(doc, pos.line).text;
+      var start = pos.ch, end = pos.ch;
+      if (line) {
+        var helper = this.getHelper(pos, "wordChars");
+        if ((pos.xRel < 0 || end == line.length) && start) --start; else ++end;
+        var startChar = line.charAt(start);
+        var check = isWordChar(startChar, helper)
+          ? function(ch) { return isWordChar(ch, helper); }
+          : /\s/.test(startChar) ? function(ch) {return /\s/.test(ch);}
+          : function(ch) {return !/\s/.test(ch) && !isWordChar(ch);};
+        while (start > 0 && check(line.charAt(start - 1))) --start;
+        while (end < line.length && check(line.charAt(end))) ++end;
+      }
+      return new Range(Pos(pos.line, start), Pos(pos.line, end));
+    },
+
+    toggleOverwrite: function(value) {
+      if (value != null && value == this.state.overwrite) return;
+      if (this.state.overwrite = !this.state.overwrite)
+        addClass(this.display.cursorDiv, "CodeMirror-overwrite");
+      else
+        rmClass(this.display.cursorDiv, "CodeMirror-overwrite");
+
+      signal(this, "overwriteToggle", this, this.state.overwrite);
+    },
+    hasFocus: function() { return this.display.input.getField() == activeElt(); },
+
+    scrollTo: methodOp(function(x, y) {
+      if (x != null || y != null) resolveScrollToPos(this);
+      if (x != null) this.curOp.scrollLeft = x;
+      if (y != null) this.curOp.scrollTop = y;
+    }),
+    getScrollInfo: function() {
+      var scroller = this.display.scroller;
+      return {left: scroller.scrollLeft, top: scroller.scrollTop,
+              height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,
+              width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,
+              clientHeight: displayHeight(this), clientWidth: displayWidth(this)};
+    },
+
+    scrollIntoView: methodOp(function(range, margin) {
+      if (range == null) {
+        range = {from: this.doc.sel.primary().head, to: null};
+        if (margin == null) margin = this.options.cursorScrollMargin;
+      } else if (typeof range == "number") {
+        range = {from: Pos(range, 0), to: null};
+      } else if (range.from == null) {
+        range = {from: range, to: null};
+      }
+      if (!range.to) range.to = range.from;
+      range.margin = margin || 0;
+
+      if (range.from.line != null) {
+        resolveScrollToPos(this);
+        this.curOp.scrollToPos = range;
+      } else {
+        var sPos = calculateScrollPos(this, Math.min(range.from.left, range.to.left),
+                                      Math.min(range.from.top, range.to.top) - range.margin,
+                                      Math.max(range.from.right, range.to.right),
+                                      Math.max(range.from.bottom, range.to.bottom) + range.margin);
+        this.scrollTo(sPos.scrollLeft, sPos.scrollTop);
+      }
+    }),
+
+    setSize: methodOp(function(width, height) {
+      var cm = this;
+      function interpret(val) {
+        return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val;
+      }
+      if (width != null) cm.display.wrapper.style.width = interpret(width);
+      if (height != null) cm.display.wrapper.style.height = interpret(height);
+      if (cm.options.lineWrapping) clearLineMeasurementCache(this);
+      var lineNo = cm.display.viewFrom;
+      cm.doc.iter(lineNo, cm.display.viewTo, function(line) {
+        if (line.widgets) for (var i = 0; i < line.widgets.length; i++)
+          if (line.widgets[i].noHScroll) { regLineChange(cm, lineNo, "widget"); break; }
+        ++lineNo;
+      });
+      cm.curOp.forceUpdate = true;
+      signal(cm, "refresh", this);
+    }),
+
+    operation: function(f){return runInOp(this, f);},
+
+    refresh: methodOp(function() {
+      var oldHeight = this.display.cachedTextHeight;
+      regChange(this);
+      this.curOp.forceUpdate = true;
+      clearCaches(this);
+      this.scrollTo(this.doc.scrollLeft, this.doc.scrollTop);
+      updateGutterSpace(this);
+      if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)
+        estimateLineHeights(this);
+      signal(this, "refresh", this);
+    }),
+
+    swapDoc: methodOp(function(doc) {
+      var old = this.doc;
+      old.cm = null;
+      attachDoc(this, doc);
+      clearCaches(this);
+      this.display.input.reset();
+      this.scrollTo(doc.scrollLeft, doc.scrollTop);
+      this.curOp.forceScroll = true;
+      signalLater(this, "swapDoc", this, old);
+      return old;
+    }),
+
+    getInputField: function(){return this.display.input.getField();},
+    getWrapperElement: function(){return this.display.wrapper;},
+    getScrollerElement: function(){return this.display.scroller;},
+    getGutterElement: function(){return this.display.gutters;}
+  };
+  eventMixin(CodeMirror);
+
+  // OPTION DEFAULTS
+
+  // The default configuration options.
+  var defaults = CodeMirror.defaults = {};
+  // Functions to run when options are changed.
+  var optionHandlers = CodeMirror.optionHandlers = {};
+
+  function option(name, deflt, handle, notOnInit) {
+    CodeMirror.defaults[name] = deflt;
+    if (handle) optionHandlers[name] =
+      notOnInit ? function(cm, val, old) {if (old != Init) handle(cm, val, old);} : handle;
+  }
+
+  // Passed to option handlers when there is no old value.
+  var Init = CodeMirror.Init = {toString: function(){return "CodeMirror.Init";}};
+
+  // These two are, on init, called from the constructor because they
+  // have to be initialized before the editor can start at all.
+  option("value", "", function(cm, val) {
+    cm.setValue(val);
+  }, true);
+  option("mode", null, function(cm, val) {
+    cm.doc.modeOption = val;
+    loadMode(cm);
+  }, true);
+
+  option("indentUnit", 2, loadMode, true);
+  option("indentWithTabs", false);
+  option("smartIndent", true);
+  option("tabSize", 4, function(cm) {
+    resetModeState(cm);
+    clearCaches(cm);
+    regChange(cm);
+  }, true);
+  option("specialChars", /[\t\u0000-\u0019\u00ad\u200b-\u200f\u2028\u2029\ufeff]/g, function(cm, val, old) {
+    cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g");
+    if (old != CodeMirror.Init) cm.refresh();
+  });
+  option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function(cm) {cm.refresh();}, true);
+  option("electricChars", true);
+  option("inputStyle", mobile ? "contenteditable" : "textarea", function() {
+    throw new Error("inputStyle can not (yet) be changed in a running editor"); // FIXME
+  }, true);
+  option("rtlMoveVisually", !windows);
+  option("wholeLineUpdateBefore", true);
+
+  option("theme", "default", function(cm) {
+    themeChanged(cm);
+    guttersChanged(cm);
+  }, true);
+  option("keyMap", "default", function(cm, val, old) {
+    var next = getKeyMap(val);
+    var prev = old != CodeMirror.Init && getKeyMap(old);
+    if (prev && prev.detach) prev.detach(cm, next);
+    if (next.attach) next.attach(cm, prev || null);
+  });
+  option("extraKeys", null);
+
+  option("lineWrapping", false, wrappingChanged, true);
+  option("gutters", [], function(cm) {
+    setGuttersForLineNumbers(cm.options);
+    guttersChanged(cm);
+  }, true);
+  option("fixedGutter", true, function(cm, val) {
+    cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0";
+    cm.refresh();
+  }, true);
+  option("coverGutterNextToScrollbar", false, function(cm) {updateScrollbars(cm);}, true);
+  option("scrollbarStyle", "native", function(cm) {
+    initScrollbars(cm);
+    updateScrollbars(cm);
+    cm.display.scrollbars.setScrollTop(cm.doc.scrollTop);
+    cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft);
+  }, true);
+  option("lineNumbers", false, function(cm) {
+    setGuttersForLineNumbers(cm.options);
+    guttersChanged(cm);
+  }, true);
+  option("firstLineNumber", 1, guttersChanged, true);
+  option("lineNumberFormatter", function(integer) {return integer;}, guttersChanged, true);
+  option("showCursorWhenSelecting", false, updateSelection, true);
+
+  option("resetSelectionOnContextMenu", true);
+  option("lineWiseCopyCut", true);
+
+  option("readOnly", false, function(cm, val) {
+    if (val == "nocursor") {
+      onBlur(cm);
+      cm.display.input.blur();
+      cm.display.disabled = true;
+    } else {
+      cm.display.disabled = false;
+      if (!val) cm.display.input.reset();
+    }
+  });
+  option("disableInput", false, function(cm, val) {if (!val) cm.display.input.reset();}, true);
+  option("dragDrop", true, dragDropChanged);
+
+  option("cursorBlinkRate", 530);
+  option("cursorScrollMargin", 0);
+  option("cursorHeight", 1, updateSelection, true);
+  option("singleCursorHeightPerLine", true, updateSelection, true);
+  option("workTime", 100);
+  option("workDelay", 100);
+  option("flattenSpans", true, resetModeState, true);
+  option("addModeClass", false, resetModeState, true);
+  option("pollInterval", 100);
+  option("undoDepth", 200, function(cm, val){cm.doc.history.undoDepth = val;});
+  option("historyEventDelay", 1250);
+  option("viewportMargin", 10, function(cm){cm.refresh();}, true);
+  option("maxHighlightLength", 10000, resetModeState, true);
+  option("moveInputWithCursor", true, function(cm, val) {
+    if (!val) cm.display.input.resetPosition();
+  });
+
+  option("tabindex", null, function(cm, val) {
+    cm.display.input.getField().tabIndex = val || "";
+  });
+  option("autofocus", null);
+
+  // MODE DEFINITION AND QUERYING
+
+  // Known modes, by name and by MIME
+  var modes = CodeMirror.modes = {}, mimeModes = CodeMirror.mimeModes = {};
+
+  // Extra arguments are stored as the mode's dependencies, which is
+  // used by (legacy) mechanisms like loadmode.js to automatically
+  // load a mode. (Preferred mechanism is the require/define calls.)
+  CodeMirror.defineMode = function(name, mode) {
+    if (!CodeMirror.defaults.mode && name != "null") CodeMirror.defaults.mode = name;
+    if (arguments.length > 2)
+      mode.dependencies = Array.prototype.slice.call(arguments, 2);
+    modes[name] = mode;
+  };
+
+  CodeMirror.defineMIME = function(mime, spec) {
+    mimeModes[mime] = spec;
+  };
+
+  // Given a MIME type, a {name, ...options} config object, or a name
+  // string, return a mode config object.
+  CodeMirror.resolveMode = function(spec) {
+    if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
+      spec = mimeModes[spec];
+    } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
+      var found = mimeModes[spec.name];
+      if (typeof found == "string") found = {name: found};
+      spec = createObj(found, spec);
+      spec.name = found.name;
+    } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
+      return CodeMirror.resolveMode("application/xml");
+    }
+    if (typeof spec == "string") return {name: spec};
+    else return spec || {name: "null"};
+  };
+
+  // Given a mode spec (anything that resolveMode accepts), find and
+  // initialize an actual mode object.
+  CodeMirror.getMode = function(options, spec) {
+    var spec = CodeMirror.resolveMode(spec);
+    var mfactory = modes[spec.name];
+    if (!mfactory) return CodeMirror.getMode(options, "text/plain");
+    var modeObj = mfactory(options, spec);
+    if (modeExtensions.hasOwnProperty(spec.name)) {
+      var exts = modeExtensions[spec.name];
+      for (var prop in exts) {
+        if (!exts.hasOwnProperty(prop)) continue;
+        if (modeObj.hasOwnProperty(prop)) modeObj["_" + prop] = modeObj[prop];
+        modeObj[prop] = exts[prop];
+      }
+    }
+    modeObj.name = spec.name;
+    if (spec.helperType) modeObj.helperType = spec.helperType;
+    if (spec.modeProps) for (var prop in spec.modeProps)
+      modeObj[prop] = spec.modeProps[prop];
+
+    return modeObj;
+  };
+
+  // Minimal default mode.
+  CodeMirror.defineMode("null", function() {
+    return {token: function(stream) {stream.skipToEnd();}};
+  });
+  CodeMirror.defineMIME("text/plain", "null");
+
+  // This can be used to attach properties to mode objects from
+  // outside the actual mode definition.
+  var modeExtensions = CodeMirror.modeExtensions = {};
+  CodeMirror.extendMode = function(mode, properties) {
+    var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});
+    copyObj(properties, exts);
+  };
+
+  // EXTENSIONS
+
+  CodeMirror.defineExtension = function(name, func) {
+    CodeMirror.prototype[name] = func;
+  };
+  CodeMirror.defineDocExtension = function(name, func) {
+    Doc.prototype[name] = func;
+  };
+  CodeMirror.defineOption = option;
+
+  var initHooks = [];
+  CodeMirror.defineInitHook = function(f) {initHooks.push(f);};
+
+  var helpers = CodeMirror.helpers = {};
+  CodeMirror.registerHelper = function(type, name, value) {
+    if (!helpers.hasOwnProperty(type)) helpers[type] = CodeMirror[type] = {_global: []};
+    helpers[type][name] = value;
+  };
+  CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {
+    CodeMirror.registerHelper(type, name, value);
+    helpers[type]._global.push({pred: predicate, val: value});
+  };
+
+  // MODE STATE HANDLING
+
+  // Utility functions for working with state. Exported because nested
+  // modes need to do this for their inner modes.
+
+  var copyState = CodeMirror.copyState = function(mode, state) {
+    if (state === true) return state;
+    if (mode.copyState) return mode.copyState(state);
+    var nstate = {};
+    for (var n in state) {
+      var val = state[n];
+      if (val instanceof Array) val = val.concat([]);
+      nstate[n] = val;
+    }
+    return nstate;
+  };
+
+  var startState = CodeMirror.startState = function(mode, a1, a2) {
+    return mode.startState ? mode.startState(a1, a2) : true;
+  };
+
+  // Given a mode and a state (for that mode), find the inner mode and
+  // state at the position that the state refers to.
+  CodeMirror.innerMode = function(mode, state) {
+    while (mode.innerMode) {
+      var info = mode.innerMode(state);
+      if (!info || info.mode == mode) break;
+      state = info.state;
+      mode = info.mode;
+    }
+    return info || {mode: mode, state: state};
+  };
+
+  // STANDARD COMMANDS
+
+  // Commands are parameter-less actions that can be performed on an
+  // editor, mostly used for keybindings.
+  var commands = CodeMirror.commands = {
+    selectAll: function(cm) {cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll);},
+    singleSelection: function(cm) {
+      cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll);
+    },
+    killLine: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        if (range.empty()) {
+          var len = getLine(cm.doc, range.head.line).text.length;
+          if (range.head.ch == len && range.head.line < cm.lastLine())
+            return {from: range.head, to: Pos(range.head.line + 1, 0)};
+          else
+            return {from: range.head, to: Pos(range.head.line, len)};
+        } else {
+          return {from: range.from(), to: range.to()};
+        }
+      });
+    },
+    deleteLine: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        return {from: Pos(range.from().line, 0),
+                to: clipPos(cm.doc, Pos(range.to().line + 1, 0))};
+      });
+    },
+    delLineLeft: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        return {from: Pos(range.from().line, 0), to: range.from()};
+      });
+    },
+    delWrappedLineLeft: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        var leftPos = cm.coordsChar({left: 0, top: top}, "div");
+        return {from: leftPos, to: range.from()};
+      });
+    },
+    delWrappedLineRight: function(cm) {
+      deleteNearSelection(cm, function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div");
+        return {from: range.from(), to: rightPos };
+      });
+    },
+    undo: function(cm) {cm.undo();},
+    redo: function(cm) {cm.redo();},
+    undoSelection: function(cm) {cm.undoSelection();},
+    redoSelection: function(cm) {cm.redoSelection();},
+    goDocStart: function(cm) {cm.extendSelection(Pos(cm.firstLine(), 0));},
+    goDocEnd: function(cm) {cm.extendSelection(Pos(cm.lastLine()));},
+    goLineStart: function(cm) {
+      cm.extendSelectionsBy(function(range) { return lineStart(cm, range.head.line); },
+                            {origin: "+move", bias: 1});
+    },
+    goLineStartSmart: function(cm) {
+      cm.extendSelectionsBy(function(range) {
+        return lineStartSmart(cm, range.head);
+      }, {origin: "+move", bias: 1});
+    },
+    goLineEnd: function(cm) {
+      cm.extendSelectionsBy(function(range) { return lineEnd(cm, range.head.line); },
+                            {origin: "+move", bias: -1});
+    },
+    goLineRight: function(cm) {
+      cm.extendSelectionsBy(function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div");
+      }, sel_move);
+    },
+    goLineLeft: function(cm) {
+      cm.extendSelectionsBy(function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        return cm.coordsChar({left: 0, top: top}, "div");
+      }, sel_move);
+    },
+    goLineLeftSmart: function(cm) {
+      cm.extendSelectionsBy(function(range) {
+        var top = cm.charCoords(range.head, "div").top + 5;
+        var pos = cm.coordsChar({left: 0, top: top}, "div");
+        if (pos.ch < cm.getLine(pos.line).search(/\S/)) return lineStartSmart(cm, range.head);
+        return pos;
+      }, sel_move);
+    },
+    goLineUp: function(cm) {cm.moveV(-1, "line");},
+    goLineDown: function(cm) {cm.moveV(1, "line");},
+    goPageUp: function(cm) {cm.moveV(-1, "page");},
+    goPageDown: function(cm) {cm.moveV(1, "page");},
+    goCharLeft: function(cm) {cm.moveH(-1, "char");},
+    goCharRight: function(cm) {cm.moveH(1, "char");},
+    goColumnLeft: function(cm) {cm.moveH(-1, "column");},
+    goColumnRight: function(cm) {cm.moveH(1, "column");},
+    goWordLeft: function(cm) {cm.moveH(-1, "word");},
+    goGroupRight: function(cm) {cm.moveH(1, "group");},
+    goGroupLeft: function(cm) {cm.moveH(-1, "group");},
+    goWordRight: function(cm) {cm.moveH(1, "word");},
+    delCharBefore: function(cm) {cm.deleteH(-1, "char");},
+    delCharAfter: function(cm) {cm.deleteH(1, "char");},
+    delWordBefore: function(cm) {cm.deleteH(-1, "word");},
+    delWordAfter: function(cm) {cm.deleteH(1, "word");},
+    delGroupBefore: function(cm) {cm.deleteH(-1, "group");},
+    delGroupAfter: function(cm) {cm.deleteH(1, "group");},
+    indentAuto: function(cm) {cm.indentSelection("smart");},
+    indentMore: function(cm) {cm.indentSelection("add");},
+    indentLess: function(cm) {cm.indentSelection("subtract");},
+    insertTab: function(cm) {cm.replaceSelection("\t");},
+    insertSoftTab: function(cm) {
+      var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize;
+      for (var i = 0; i < ranges.length; i++) {
+        var pos = ranges[i].from();
+        var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize);
+        spaces.push(new Array(tabSize - col % tabSize + 1).join(" "));
+      }
+      cm.replaceSelections(spaces);
+    },
+    defaultTab: function(cm) {
+      if (cm.somethingSelected()) cm.indentSelection("add");
+      else cm.execCommand("insertTab");
+    },
+    transposeChars: function(cm) {
+      runInOp(cm, function() {
+        var ranges = cm.listSelections(), newSel = [];
+        for (var i = 0; i < ranges.length; i++) {
+          var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text;
+          if (line) {
+            if (cur.ch == line.length) cur = new Pos(cur.line, cur.ch - 1);
+            if (cur.ch > 0) {
+              cur = new Pos(cur.line, cur.ch + 1);
+              cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
+                              Pos(cur.line, cur.ch - 2), cur, "+transpose");
+            } else if (cur.line > cm.doc.first) {
+              var prev = getLine(cm.doc, cur.line - 1).text;
+              if (prev)
+                cm.replaceRange(line.charAt(0) + "\n" + prev.charAt(prev.length - 1),
+                                Pos(cur.line - 1, prev.length - 1), Pos(cur.line, 1), "+transpose");
+            }
+          }
+          newSel.push(new Range(cur, cur));
+        }
+        cm.setSelections(newSel);
+      });
+    },
+    newlineAndIndent: function(cm) {
+      runInOp(cm, function() {
+        var len = cm.listSelections().length;
+        for (var i = 0; i < len; i++) {
+          var range = cm.listSelections()[i];
+          cm.replaceRange("\n", range.anchor, range.head, "+input");
+          cm.indentLine(range.from().line + 1, null, true);
+          ensureCursorVisible(cm);
+        }
+      });
+    },
+    toggleOverwrite: function(cm) {cm.toggleOverwrite();}
+  };
+
+
+  // STANDARD KEYMAPS
+
+  var keyMap = CodeMirror.keyMap = {};
+
+  keyMap.basic = {
+    "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
+    "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
+    "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore",
+    "Tab": "defaultTab", "Shift-Tab": "indentAuto",
+    "Enter": "newlineAndIndent", "Insert": "toggleOverwrite",
+    "Esc": "singleSelection"
+  };
+  // Note that the save and find-related commands aren't defined by
+  // default. User code or addons can define them. Unknown commands
+  // are simply ignored.
+  keyMap.pcDefault = {
+    "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
+    "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown",
+    "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
+    "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
+    "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
+    "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
+    "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection",
+    fallthrough: "basic"
+  };
+  // Very basic readline/emacs-style bindings, which are standard on Mac.
+  keyMap.emacsy = {
+    "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
+    "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
+    "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
+    "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars"
+  };
+  keyMap.macDefault = {
+    "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
+    "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
+    "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore",
+    "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
+    "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
+    "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight",
+    "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd",
+    fallthrough: ["basic", "emacsy"]
+  };
+  keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault;
+
+  // KEYMAP DISPATCH
+
+  function normalizeKeyName(name) {
+    var parts = name.split(/-(?!$)/), name = parts[parts.length - 1];
+    var alt, ctrl, shift, cmd;
+    for (var i = 0; i < parts.length - 1; i++) {
+      var mod = parts[i];
+      if (/^(cmd|meta|m)$/i.test(mod)) cmd = true;
+      else if (/^a(lt)?$/i.test(mod)) alt = true;
+      else if (/^(c|ctrl|control)$/i.test(mod)) ctrl = true;
+      else if (/^s(hift)$/i.test(mod)) shift = true;
+      else throw new Error("Unrecognized modifier name: " + mod);
+    }
+    if (alt) name = "Alt-" + name;
+    if (ctrl) name = "Ctrl-" + name;
+    if (cmd) name = "Cmd-" + name;
+    if (shift) name = "Shift-" + name;
+    return name;
+  }
+
+  // This is a kludge to keep keymaps mostly working as raw objects
+  // (backwards compatibility) while at the same time support features
+  // like normalization and multi-stroke key bindings. It compiles a
+  // new normalized keymap, and then updates the old object to reflect
+  // this.
+  CodeMirror.normalizeKeyMap = function(keymap) {
+    var copy = {};
+    for (var keyname in keymap) if (keymap.hasOwnProperty(keyname)) {
+      var value = keymap[keyname];
+      if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) continue;
+      if (value == "...") { delete keymap[keyname]; continue; }
+
+      var keys = map(keyname.split(" "), normalizeKeyName);
+      for (var i = 0; i < keys.length; i++) {
+        var val, name;
+        if (i == keys.length - 1) {
+          name = keys.join(" ");
+          val = value;
+        } else {
+          name = keys.slice(0, i + 1).join(" ");
+          val = "...";
+        }
+        var prev = copy[name];
+        if (!prev) copy[name] = val;
+        else if (prev != val) throw new Error("Inconsistent bindings for " + name);
+      }
+      delete keymap[keyname];
+    }
+    for (var prop in copy) keymap[prop] = copy[prop];
+    return keymap;
+  };
+
+  var lookupKey = CodeMirror.lookupKey = function(key, map, handle, context) {
+    map = getKeyMap(map);
+    var found = map.call ? map.call(key, context) : map[key];
+    if (found === false) return "nothing";
+    if (found === "...") return "multi";
+    if (found != null && handle(found)) return "handled";
+
+    if (map.fallthrough) {
+      if (Object.prototype.toString.call(map.fallthrough) != "[object Array]")
+        return lookupKey(key, map.fallthrough, handle, context);
+      for (var i = 0; i < map.fallthrough.length; i++) {
+        var result = lookupKey(key, map.fallthrough[i], handle, context);
+        if (result) return result;
+      }
+    }
+  };
+
+  // Modifier key presses don't count as 'real' key presses for the
+  // purpose of keymap fallthrough.
+  var isModifierKey = CodeMirror.isModifierKey = function(value) {
+    var name = typeof value == "string" ? value : keyNames[value.keyCode];
+    return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod";
+  };
+
+  // Look up the name of a key as indicated by an event object.
+  var keyName = CodeMirror.keyName = function(event, noShift) {
+    if (presto && event.keyCode == 34 && event["char"]) return false;
+    var base = keyNames[event.keyCode], name = base;
+    if (name == null || event.altGraphKey) return false;
+    if (event.altKey && base != "Alt") name = "Alt-" + name;
+    if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") name = "Ctrl-" + name;
+    if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") name = "Cmd-" + name;
+    if (!noShift && event.shiftKey && base != "Shift") name = "Shift-" + name;
+    return name;
+  };
+
+  function getKeyMap(val) {
+    return typeof val == "string" ? keyMap[val] : val;
+  }
+
+  // FROMTEXTAREA
+
+  CodeMirror.fromTextArea = function(textarea, options) {
+    options = options ? copyObj(options) : {};
+    options.value = textarea.value;
+    if (!options.tabindex && textarea.tabIndex)
+      options.tabindex = textarea.tabIndex;
+    if (!options.placeholder && textarea.placeholder)
+      options.placeholder = textarea.placeholder;
+    // Set autofocus to true if this textarea is focused, or if it has
+    // autofocus and no other element is focused.
+    if (options.autofocus == null) {
+      var hasFocus = activeElt();
+      options.autofocus = hasFocus == textarea ||
+        textarea.getAttribute("autofocus") != null && hasFocus == document.body;
+    }
+
+    function save() {textarea.value = cm.getValue();}
+    if (textarea.form) {
+      on(textarea.form, "submit", save);
+      // Deplorable hack to make the submit method do the right thing.
+      if (!options.leaveSubmitMethodAlone) {
+        var form = textarea.form, realSubmit = form.submit;
+        try {
+          var wrappedSubmit = form.submit = function() {
+            save();
+            form.submit = realSubmit;
+            form.submit();
+            form.submit = wrappedSubmit;
+          };
+        } catch(e) {}
+      }
+    }
+
+    options.finishInit = function(cm) {
+      cm.save = save;
+      cm.getTextArea = function() { return textarea; };
+      cm.toTextArea = function() {
+        cm.toTextArea = isNaN; // Prevent this from being ran twice
+        save();
+        textarea.parentNode.removeChild(cm.getWrapperElement());
+        textarea.style.display = "";
+        if (textarea.form) {
+          off(textarea.form, "submit", save);
+          if (typeof textarea.form.submit == "function")
+            textarea.form.submit = realSubmit;
+        }
+      };
+    };
+
+    textarea.style.display = "none";
+    var cm = CodeMirror(function(node) {
+      textarea.parentNode.insertBefore(node, textarea.nextSibling);
+    }, options);
+    return cm;
+  };
+
+  // STRING STREAM
+
+  // Fed to the mode parsers, provides helper functions to make
+  // parsers more succinct.
+
+  var StringStream = CodeMirror.StringStream = function(string, tabSize) {
+    this.pos = this.start = 0;
+    this.string = string;
+    this.tabSize = tabSize || 8;
+    this.lastColumnPos = this.lastColumnValue = 0;
+    this.lineStart = 0;
+  };
+
+  StringStream.prototype = {
+    eol: function() {return this.pos >= this.string.length;},
+    sol: function() {return this.pos == this.lineStart;},
+    peek: function() {return this.string.charAt(this.pos) || undefined;},
+    next: function() {
+      if (this.pos < this.string.length)
+        return this.string.charAt(this.pos++);
+    },
+    eat: function(match) {
+      var ch = this.string.charAt(this.pos);
+      if (typeof match == "string") var ok = ch == match;
+      else var ok = ch && (match.test ? match.test(ch) : match(ch));
+      if (ok) {++this.pos; return ch;}
+    },
+    eatWhile: function(match) {
+      var start = this.pos;
+      while (this.eat(match)){}
+      return this.pos > start;
+    },
+    eatSpace: function() {
+      var start = this.pos;
+      while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
+      return this.pos > start;
+    },
+    skipToEnd: function() {this.pos = this.string.length;},
+    skipTo: function(ch) {
+      var found = this.string.indexOf(ch, this.pos);
+      if (found > -1) {this.pos = found; return true;}
+    },
+    backUp: function(n) {this.pos -= n;},
+    column: function() {
+      if (this.lastColumnPos < this.start) {
+        this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);
+        this.lastColumnPos = this.start;
+      }
+      return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);
+    },
+    indentation: function() {
+      return countColumn(this.string, null, this.tabSize) -
+        (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);
+    },
+    match: function(pattern, consume, caseInsensitive) {
+      if (typeof pattern == "string") {
+        var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;};
+        var substr = this.string.substr(this.pos, pattern.length);
+        if (cased(substr) == cased(pattern)) {
+          if (consume !== false) this.pos += pattern.length;
+          return true;
+        }
+      } else {
+        var match = this.string.slice(this.pos).match(pattern);
+        if (match && match.index > 0) return null;
+        if (match && consume !== false) this.pos += match[0].length;
+        return match;
+      }
+    },
+    current: function(){return this.string.slice(this.start, this.pos);},
+    hideFirstChars: function(n, inner) {
+      this.lineStart += n;
+      try { return inner(); }
+      finally { this.lineStart -= n; }
+    }
+  };
+
+  // TEXTMARKERS
+
+  // Created with markText and setBookmark methods. A TextMarker is a
+  // handle that can be used to clear or find a marked position in the
+  // document. Line objects hold arrays (markedSpans) containing
+  // {from, to, marker} object pointing to such marker objects, and
+  // indicating that such a marker is present on that line. Multiple
+  // lines may point to the same marker when it spans across lines.
+  // The spans will have null for their from/to properties when the
+  // marker continues beyond the start/end of the line. Markers have
+  // links back to the lines they currently touch.
+
+  var nextMarkerId = 0;
+
+  var TextMarker = CodeMirror.TextMarker = function(doc, type) {
+    this.lines = [];
+    this.type = type;
+    this.doc = doc;
+    this.id = ++nextMarkerId;
+  };
+  eventMixin(TextMarker);
+
+  // Clear the marker.
+  TextMarker.prototype.clear = function() {
+    if (this.explicitlyCleared) return;
+    var cm = this.doc.cm, withOp = cm && !cm.curOp;
+    if (withOp) startOperation(cm);
+    if (hasHandler(this, "clear")) {
+      var found = this.find();
+      if (found) signalLater(this, "clear", found.from, found.to);
+    }
+    var min = null, max = null;
+    for (var i = 0; i < this.lines.length; ++i) {
+      var line = this.lines[i];
+      var span = getMarkedSpanFor(line.markedSpans, this);
+      if (cm && !this.collapsed) regLineChange(cm, lineNo(line), "text");
+      else if (cm) {
+        if (span.to != null) max = lineNo(line);
+        if (span.from != null) min = lineNo(line);
+      }
+      line.markedSpans = removeMarkedSpan(line.markedSpans, span);
+      if (span.from == null && this.collapsed && !lineIsHidden(this.doc, line) && cm)
+        updateLineHeight(line, textHeight(cm.display));
+    }
+    if (cm && this.collapsed && !cm.options.lineWrapping) for (var i = 0; i < this.lines.length; ++i) {
+      var visual = visualLine(this.lines[i]), len = lineLength(visual);
+      if (len > cm.display.maxLineLength) {
+        cm.display.maxLine = visual;
+        cm.display.maxLineLength = len;
+        cm.display.maxLineChanged = true;
+      }
+    }
+
+    if (min != null && cm && this.collapsed) regChange(cm, min, max + 1);
+    this.lines.length = 0;
+    this.explicitlyCleared = true;
+    if (this.atomic && this.doc.cantEdit) {
+      this.doc.cantEdit = false;
+      if (cm) reCheckSelection(cm.doc);
+    }
+    if (cm) signalLater(cm, "markerCleared", cm, this);
+    if (withOp) endOperation(cm);
+    if (this.parent) this.parent.clear();
+  };
+
+  // Find the position of the marker in the document. Returns a {from,
+  // to} object by default. Side can be passed to get a specific side
+  // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the
+  // Pos objects returned contain a line object, rather than a line
+  // number (used to prevent looking up the same line twice).
+  TextMarker.prototype.find = function(side, lineObj) {
+    if (side == null && this.type == "bookmark") side = 1;
+    var from, to;
+    for (var i = 0; i < this.lines.length; ++i) {
+      var line = this.lines[i];
+      var span = getMarkedSpanFor(line.markedSpans, this);
+      if (span.from != null) {
+        from = Pos(lineObj ? line : lineNo(line), span.from);
+        if (side == -1) return from;
+      }
+      if (span.to != null) {
+        to = Pos(lineObj ? line : lineNo(line), span.to);
+        if (side == 1) return to;
+      }
+    }
+    return from && {from: from, to: to};
+  };
+
+  // Signals that the marker's widget changed, and surrounding layout
+  // should be recomputed.
+  TextMarker.prototype.changed = function() {
+    var pos = this.find(-1, true), widget = this, cm = this.doc.cm;
+    if (!pos || !cm) return;
+    runInOp(cm, function() {
+      var line = pos.line, lineN = lineNo(pos.line);
+      var view = findViewForLine(cm, lineN);
+      if (view) {
+        clearLineMeasurementCacheFor(view);
+        cm.curOp.selectionChanged = cm.curOp.forceUpdate = true;
+      }
+      cm.curOp.updateMaxLine = true;
+      if (!lineIsHidden(widget.doc, line) && widget.height != null) {
+        var oldHeight = widget.height;
+        widget.height = null;
+        var dHeight = widgetHeight(widget) - oldHeight;
+        if (dHeight)
+          updateLineHeight(line, line.height + dHeight);
+      }
+    });
+  };
+
+  TextMarker.prototype.attachLine = function(line) {
+    if (!this.lines.length && this.doc.cm) {
+      var op = this.doc.cm.curOp;
+      if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)
+        (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this);
+    }
+    this.lines.push(line);
+  };
+  TextMarker.prototype.detachLine = function(line) {
+    this.lines.splice(indexOf(this.lines, line), 1);
+    if (!this.lines.length && this.doc.cm) {
+      var op = this.doc.cm.curOp;
+      (op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this);
+    }
+  };
+
+  // Collapsed markers have unique ids, in order to be able to order
+  // them, which is needed for uniquely determining an outer marker
+  // when they overlap (they may nest, but not partially overlap).
+  var nextMarkerId = 0;
+
+  // Create a marker, wire it up to the right lines, and
+  function markText(doc, from, to, options, type) {
+    // Shared markers (across linked documents) are handled separately
+    // (markTextShared will call out to this again, once per
+    // document).
+    if (options && options.shared) return markTextShared(doc, from, to, options, type);
+    // Ensure we are in an operation.
+    if (doc.cm && !doc.cm.curOp) return operation(doc.cm, markText)(doc, from, to, options, type);
+
+    var marker = new TextMarker(doc, type), diff = cmp(from, to);
+    if (options) copyObj(options, marker, false);
+    // Don't connect empty markers unless clearWhenEmpty is false
+    if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)
+      return marker;
+    if (marker.replacedWith) {
+      // Showing up as a widget implies collapsed (widget replaces text)
+      marker.collapsed = true;
+      marker.widgetNode = elt("span", [marker.replacedWith], "CodeMirror-widget");
+      if (!options.handleMouseEvents) marker.widgetNode.setAttribute("cm-ignore-events", "true");
+      if (options.insertLeft) marker.widgetNode.insertLeft = true;
+    }
+    if (marker.collapsed) {
+      if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||
+          from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))
+        throw new Error("Inserting collapsed marker partially overlapping an existing one");
+      sawCollapsedSpans = true;
+    }
+
+    if (marker.addToHistory)
+      addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN);
+
+    var curLine = from.line, cm = doc.cm, updateMaxLine;
+    doc.iter(curLine, to.line + 1, function(line) {
+      if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)
+        updateMaxLine = true;
+      if (marker.collapsed && curLine != from.line) updateLineHeight(line, 0);
+      addMarkedSpan(line, new MarkedSpan(marker,
+                                         curLine == from.line ? from.ch : null,
+                                         curLine == to.line ? to.ch : null));
+      ++curLine;
+    });
+    // lineIsHidden depends on the presence of the spans, so needs a second pass
+    if (marker.collapsed) doc.iter(from.line, to.line + 1, function(line) {
+      if (lineIsHidden(doc, line)) updateLineHeight(line, 0);
+    });
+
+    if (marker.clearOnEnter) on(marker, "beforeCursorEnter", function() { marker.clear(); });
+
+    if (marker.readOnly) {
+      sawReadOnlySpans = true;
+      if (doc.history.done.length || doc.history.undone.length)
+        doc.clearHistory();
+    }
+    if (marker.collapsed) {
+      marker.id = ++nextMarkerId;
+      marker.atomic = true;
+    }
+    if (cm) {
+      // Sync editor state
+      if (updateMaxLine) cm.curOp.updateMaxLine = true;
+      if (marker.collapsed)
+        regChange(cm, from.line, to.line + 1);
+      else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css)
+        for (var i = from.line; i <= to.line; i++) regLineChange(cm, i, "text");
+      if (marker.atomic) reCheckSelection(cm.doc);
+      signalLater(cm, "markerAdded", cm, marker);
+    }
+    return marker;
+  }
+
+  // SHARED TEXTMARKERS
+
+  // A shared marker spans multiple linked documents. It is
+  // implemented as a meta-marker-object controlling multiple normal
+  // markers.
+  var SharedTextMarker = CodeMirror.SharedTextMarker = function(markers, primary) {
+    this.markers = markers;
+    this.primary = primary;
+    for (var i = 0; i < markers.length; ++i)
+      markers[i].parent = this;
+  };
+  eventMixin(SharedTextMarker);
+
+  SharedTextMarker.prototype.clear = function() {
+    if (this.explicitlyCleared) return;
+    this.explicitlyCleared = true;
+    for (var i = 0; i < this.markers.length; ++i)
+      this.markers[i].clear();
+    signalLater(this, "clear");
+  };
+  SharedTextMarker.prototype.find = function(side, lineObj) {
+    return this.primary.find(side, lineObj);
+  };
+
+  function markTextShared(doc, from, to, options, type) {
+    options = copyObj(options);
+    options.shared = false;
+    var markers = [markText(doc, from, to, options, type)], primary = markers[0];
+    var widget = options.widgetNode;
+    linkedDocs(doc, function(doc) {
+      if (widget) options.widgetNode = widget.cloneNode(true);
+      markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type));
+      for (var i = 0; i < doc.linked.length; ++i)
+        if (doc.linked[i].isParent) return;
+      primary = lst(markers);
+    });
+    return new SharedTextMarker(markers, primary);
+  }
+
+  function findSharedMarkers(doc) {
+    return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())),
+                         function(m) { return m.parent; });
+  }
+
+  function copySharedMarkers(doc, markers) {
+    for (var i = 0; i < markers.length; i++) {
+      var marker = markers[i], pos = marker.find();
+      var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to);
+      if (cmp(mFrom, mTo)) {
+        var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type);
+        marker.markers.push(subMark);
+        subMark.parent = marker;
+      }
+    }
+  }
+
+  function detachSharedMarkers(markers) {
+    for (var i = 0; i < markers.length; i++) {
+      var marker = markers[i], linked = [marker.primary.doc];;
+      linkedDocs(marker.primary.doc, function(d) { linked.push(d); });
+      for (var j = 0; j < marker.markers.length; j++) {
+        var subMarker = marker.markers[j];
+        if (indexOf(linked, subMarker.doc) == -1) {
+          subMarker.parent = null;
+          marker.markers.splice(j--, 1);
+        }
+      }
+    }
+  }
+
+  // TEXTMARKER SPANS
+
+  function MarkedSpan(marker, from, to) {
+    this.marker = marker;
+    this.from = from; this.to = to;
+  }
+
+  // Search an array of spans for a span matching the given marker.
+  function getMarkedSpanFor(spans, marker) {
+    if (spans) for (var i = 0; i < spans.length; ++i) {
+      var span = spans[i];
+      if (span.marker == marker) return span;
+    }
+  }
+  // Remove a span from an array, returning undefined if no spans are
+  // left (we don't store arrays for lines without spans).
+  function removeMarkedSpan(spans, span) {
+    for (var r, i = 0; i < spans.length; ++i)
+      if (spans[i] != span) (r || (r = [])).push(spans[i]);
+    return r;
+  }
+  // Add a span to a line.
+  function addMarkedSpan(line, span) {
+    line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span];
+    span.marker.attachLine(line);
+  }
+
+  // Used for the algorithm that adjusts markers for a change in the
+  // document. These functions cut an array of spans at a given
+  // character position, returning an array of remaining chunks (or
+  // undefined if nothing remains).
+  function markedSpansBefore(old, startCh, isInsert) {
+    if (old) for (var i = 0, nw; i < old.length; ++i) {
+      var span = old[i], marker = span.marker;
+      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh);
+      if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {
+        var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh);
+        (nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to));
+      }
+    }
+    return nw;
+  }
+  function markedSpansAfter(old, endCh, isInsert) {
+    if (old) for (var i = 0, nw; i < old.length; ++i) {
+      var span = old[i], marker = span.marker;
+      var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh);
+      if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {
+        var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh);
+        (nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,
+                                              span.to == null ? null : span.to - endCh));
+      }
+    }
+    return nw;
+  }
+
+  // Given a change object, compute the new set of marker spans that
+  // cover the line in which the change took place. Removes spans
+  // entirely within the change, reconnects spans belonging to the
+  // same marker that appear on both sides of the change, and cuts off
+  // spans partially within the change. Returns an array of span
+  // arrays with one element for each line in (after) the change.
+  function stretchSpansOverChange(doc, change) {
+    if (change.full) return null;
+    var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans;
+    var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans;
+    if (!oldFirst && !oldLast) return null;
+
+    var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0;
+    // Get the spans that 'stick out' on both sides
+    var first = markedSpansBefore(oldFirst, startCh, isInsert);
+    var last = markedSpansAfter(oldLast, endCh, isInsert);
+
+    // Next, merge those two ends
+    var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0);
+    if (first) {
+      // Fix up .to properties of first
+      for (var i = 0; i < first.length; ++i) {
+        var span = first[i];
+        if (span.to == null) {
+          var found = getMarkedSpanFor(last, span.marker);
+          if (!found) span.to = startCh;
+          else if (sameLine) span.to = found.to == null ? null : found.to + offset;
+        }
+      }
+    }
+    if (last) {
+      // Fix up .from in last (or move them into first in case of sameLine)
+      for (var i = 0; i < last.length; ++i) {
+        var span = last[i];
+        if (span.to != null) span.to += offset;
+        if (span.from == null) {
+          var found = getMarkedSpanFor(first, span.marker);
+          if (!found) {
+            span.from = offset;
+            if (sameLine) (first || (first = [])).push(span);
+          }
+        } else {
+          span.from += offset;
+          if (sameLine) (first || (first = [])).push(span);
+        }
+      }
+    }
+    // Make sure we didn't create any zero-length spans
+    if (first) first = clearEmptySpans(first);
+    if (last && last != first) last = clearEmptySpans(last);
+
+    var newMarkers = [first];
+    if (!sameLine) {
+      // Fill gap with whole-line-spans
+      var gap = change.text.length - 2, gapMarkers;
+      if (gap > 0 && first)
+        for (var i = 0; i < first.length; ++i)
+          if (first[i].to == null)
+            (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i].marker, null, null));
+      for (var i = 0; i < gap; ++i)
+        newMarkers.push(gapMarkers);
+      newMarkers.push(last);
+    }
+    return newMarkers;
+  }
+
+  // Remove spans that are empty and don't have a clearWhenEmpty
+  // option of false.
+  function clearEmptySpans(spans) {
+    for (var i = 0; i < spans.length; ++i) {
+      var span = spans[i];
+      if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)
+        spans.splice(i--, 1);
+    }
+    if (!spans.length) return null;
+    return spans;
+  }
+
+  // Used for un/re-doing changes from the history. Combines the
+  // result of computing the existing spans with the set of spans that
+  // existed in the history (so that deleting around a span and then
+  // undoing brings back the span).
+  function mergeOldSpans(doc, change) {
+    var old = getOldSpans(doc, change);
+    var stretched = stretchSpansOverChange(doc, change);
+    if (!old) return stretched;
+    if (!stretched) return old;
+
+    for (var i = 0; i < old.length; ++i) {
+      var oldCur = old[i], stretchCur = stretched[i];
+      if (oldCur && stretchCur) {
+        spans: for (var j = 0; j < stretchCur.length; ++j) {
+          var span = stretchCur[j];
+          for (var k = 0; k < oldCur.length; ++k)
+            if (oldCur[k].marker == span.marker) continue spans;
+          oldCur.push(span);
+        }
+      } else if (stretchCur) {
+        old[i] = stretchCur;
+      }
+    }
+    return old;
+  }
+
+  // Used to 'clip' out readOnly ranges when making a change.
+  function removeReadOnlyRanges(doc, from, to) {
+    var markers = null;
+    doc.iter(from.line, to.line + 1, function(line) {
+      if (line.markedSpans) for (var i = 0; i < line.markedSpans.length; ++i) {
+        var mark = line.markedSpans[i].marker;
+        if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))
+          (markers || (markers = [])).push(mark);
+      }
+    });
+    if (!markers) return null;
+    var parts = [{from: from, to: to}];
+    for (var i = 0; i < markers.length; ++i) {
+      var mk = markers[i], m = mk.find(0);
+      for (var j = 0; j < parts.length; ++j) {
+        var p = parts[j];
+        if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) continue;
+        var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to);
+        if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)
+          newParts.push({from: p.from, to: m.from});
+        if (dto > 0 || !mk.inclusiveRight && !dto)
+          newParts.push({from: m.to, to: p.to});
+        parts.splice.apply(parts, newParts);
+        j += newParts.length - 1;
+      }
+    }
+    return parts;
+  }
+
+  // Connect or disconnect spans from a line.
+  function detachMarkedSpans(line) {
+    var spans = line.markedSpans;
+    if (!spans) return;
+    for (var i = 0; i < spans.length; ++i)
+      spans[i].marker.detachLine(line);
+    line.markedSpans = null;
+  }
+  function attachMarkedSpans(line, spans) {
+    if (!spans) return;
+    for (var i = 0; i < spans.length; ++i)
+      spans[i].marker.attachLine(line);
+    line.markedSpans = spans;
+  }
+
+  // Helpers used when computing which overlapping collapsed span
+  // counts as the larger one.
+  function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0; }
+  function extraRight(marker) { return marker.inclusiveRight ? 1 : 0; }
+
+  // Returns a number indicating which of two overlapping collapsed
+  // spans is larger (and thus includes the other). Falls back to
+  // comparing ids when the spans cover exactly the same range.
+  function compareCollapsedMarkers(a, b) {
+    var lenDiff = a.lines.length - b.lines.length;
+    if (lenDiff != 0) return lenDiff;
+    var aPos = a.find(), bPos = b.find();
+    var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b);
+    if (fromCmp) return -fromCmp;
+    var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b);
+    if (toCmp) return toCmp;
+    return b.id - a.id;
+  }
+
+  // Find out whether a line ends or starts in a collapsed span. If
+  // so, return the marker for that span.
+  function collapsedSpanAtSide(line, start) {
+    var sps = sawCollapsedSpans && line.markedSpans, found;
+    if (sps) for (var sp, i = 0; i < sps.length; ++i) {
+      sp = sps[i];
+      if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&
+          (!found || compareCollapsedMarkers(found, sp.marker) < 0))
+        found = sp.marker;
+    }
+    return found;
+  }
+  function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true); }
+  function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false); }
+
+  // Test whether there exists a collapsed span that partially
+  // overlaps (covers the start or end, but not both) of a new span.
+  // Such overlap is not allowed.
+  function conflictingCollapsedRange(doc, lineNo, from, to, marker) {
+    var line = getLine(doc, lineNo);
+    var sps = sawCollapsedSpans && line.markedSpans;
+    if (sps) for (var i = 0; i < sps.length; ++i) {
+      var sp = sps[i];
+      if (!sp.marker.collapsed) continue;
+      var found = sp.marker.find(0);
+      var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker);
+      var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker);
+      if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) continue;
+      if (fromCmp <= 0 && (cmp(found.to, from) > 0 || (sp.marker.inclusiveRight && marker.inclusiveLeft)) ||
+          fromCmp >= 0 && (cmp(found.from, to) < 0 || (sp.marker.inclusiveLeft && marker.inclusiveRight)))
+        return true;
+    }
+  }
+
+  // A visual line is a line as drawn on the screen. Folding, for
+  // example, can cause multiple logical lines to appear on the same
+  // visual line. This finds the start of the visual line that the
+  // given line is part of (usually that is the line itself).
+  function visualLine(line) {
+    var merged;
+    while (merged = collapsedSpanAtStart(line))
+      line = merged.find(-1, true).line;
+    return line;
+  }
+
+  // Returns an array of logical lines that continue the visual line
+  // started by the argument, or undefined if there are no such lines.
+  function visualLineContinued(line) {
+    var merged, lines;
+    while (merged = collapsedSpanAtEnd(line)) {
+      line = merged.find(1, true).line;
+      (lines || (lines = [])).push(line);
+    }
+    return lines;
+  }
+
+  // Get the line number of the start of the visual line that the
+  // given line number is part of.
+  function visualLineNo(doc, lineN) {
+    var line = getLine(doc, lineN), vis = visualLine(line);
+    if (line == vis) return lineN;
+    return lineNo(vis);
+  }
+  // Get the line number of the start of the next visual line after
+  // the given line.
+  function visualLineEndNo(doc, lineN) {
+    if (lineN > doc.lastLine()) return lineN;
+    var line = getLine(doc, lineN), merged;
+    if (!lineIsHidden(doc, line)) return lineN;
+    while (merged = collapsedSpanAtEnd(line))
+      line = merged.find(1, true).line;
+    return lineNo(line) + 1;
+  }
+
+  // Compute whether a line is hidden. Lines count as hidden when they
+  // are part of a visual line that starts with another line, or when
+  // they are entirely covered by collapsed, non-widget span.
+  function lineIsHidden(doc, line) {
+    var sps = sawCollapsedSpans && line.markedSpans;
+    if (sps) for (var sp, i = 0; i < sps.length; ++i) {
+      sp = sps[i];
+      if (!sp.marker.collapsed) continue;
+      if (sp.from == null) return true;
+      if (sp.marker.widgetNode) continue;
+      if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))
+        return true;
+    }
+  }
+  function lineIsHiddenInner(doc, line, span) {
+    if (span.to == null) {
+      var end = span.marker.find(1, true);
+      return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker));
+    }
+    if (span.marker.inclusiveRight && span.to == line.text.length)
+      return true;
+    for (var sp, i = 0; i < line.markedSpans.length; ++i) {
+      sp = line.markedSpans[i];
+      if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&
+          (sp.to == null || sp.to != span.from) &&
+          (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
+          lineIsHiddenInner(doc, line, sp)) return true;
+    }
+  }
+
+  // LINE WIDGETS
+
+  // Line widgets are block elements displayed above or below a line.
+
+  var LineWidget = CodeMirror.LineWidget = function(doc, node, options) {
+    if (options) for (var opt in options) if (options.hasOwnProperty(opt))
+      this[opt] = options[opt];
+    this.doc = doc;
+    this.node = node;
+  };
+  eventMixin(LineWidget);
+
+  function adjustScrollWhenAboveVisible(cm, line, diff) {
+    if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))
+      addToScrollPos(cm, null, diff);
+  }
+
+  LineWidget.prototype.clear = function() {
+    var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line);
+    if (no == null || !ws) return;
+    for (var i = 0; i < ws.length; ++i) if (ws[i] == this) ws.splice(i--, 1);
+    if (!ws.length) line.widgets = null;
+    var height = widgetHeight(this);
+    updateLineHeight(line, Math.max(0, line.height - height));
+    if (cm) runInOp(cm, function() {
+      adjustScrollWhenAboveVisible(cm, line, -height);
+      regLineChange(cm, no, "widget");
+    });
+  };
+  LineWidget.prototype.changed = function() {
+    var oldH = this.height, cm = this.doc.cm, line = this.line;
+    this.height = null;
+    var diff = widgetHeight(this) - oldH;
+    if (!diff) return;
+    updateLineHeight(line, line.height + diff);
+    if (cm) runInOp(cm, function() {
+      cm.curOp.forceUpdate = true;
+      adjustScrollWhenAboveVisible(cm, line, diff);
+    });
+  };
+
+  function widgetHeight(widget) {
+    if (widget.height != null) return widget.height;
+    var cm = widget.doc.cm;
+    if (!cm) return 0;
+    if (!contains(document.body, widget.node)) {
+      var parentStyle = "position: relative;";
+      if (widget.coverGutter)
+        parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;";
+      if (widget.noHScroll)
+        parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;";
+      removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle));
+    }
+    return widget.height = widget.node.offsetHeight;
+  }
+
+  function addLineWidget(doc, handle, node, options) {
+    var widget = new LineWidget(doc, node, options);
+    var cm = doc.cm;
+    if (cm && widget.noHScroll) cm.display.alignWidgets = true;
+    changeLine(doc, handle, "widget", function(line) {
+      var widgets = line.widgets || (line.widgets = []);
+      if (widget.insertAt == null) widgets.push(widget);
+      else widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget);
+      widget.line = line;
+      if (cm && !lineIsHidden(doc, line)) {
+        var aboveVisible = heightAtLine(line) < doc.scrollTop;
+        updateLineHeight(line, line.height + widgetHeight(widget));
+        if (aboveVisible) addToScrollPos(cm, null, widget.height);
+        cm.curOp.forceUpdate = true;
+      }
+      return true;
+    });
+    return widget;
+  }
+
+  // LINE DATA STRUCTURE
+
+  // Line objects. These hold state related to a line, including
+  // highlighting info (the styles array).
+  var Line = CodeMirror.Line = function(text, markedSpans, estimateHeight) {
+    this.text = text;
+    attachMarkedSpans(this, markedSpans);
+    this.height = estimateHeight ? estimateHeight(this) : 1;
+  };
+  eventMixin(Line);
+  Line.prototype.lineNo = function() { return lineNo(this); };
+
+  // Change the content (text, markers) of a line. Automatically
+  // invalidates cached information and tries to re-estimate the
+  // line's height.
+  function updateLine(line, text, markedSpans, estimateHeight) {
+    line.text = text;
+    if (line.stateAfter) line.stateAfter = null;
+    if (line.styles) line.styles = null;
+    if (line.order != null) line.order = null;
+    detachMarkedSpans(line);
+    attachMarkedSpans(line, markedSpans);
+    var estHeight = estimateHeight ? estimateHeight(line) : 1;
+    if (estHeight != line.height) updateLineHeight(line, estHeight);
+  }
+
+  // Detach a line from the document tree and its markers.
+  function cleanUpLine(line) {
+    line.parent = null;
+    detachMarkedSpans(line);
+  }
+
+  function extractLineClasses(type, output) {
+    if (type) for (;;) {
+      var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/);
+      if (!lineClass) break;
+      type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length);
+      var prop = lineClass[1] ? "bgClass" : "textClass";
+      if (output[prop] == null)
+        output[prop] = lineClass[2];
+      else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop]))
+        output[prop] += " " + lineClass[2];
+    }
+    return type;
+  }
+
+  function callBlankLine(mode, state) {
+    if (mode.blankLine) return mode.blankLine(state);
+    if (!mode.innerMode) return;
+    var inner = CodeMirror.innerMode(mode, state);
+    if (inner.mode.blankLine) return inner.mode.blankLine(inner.state);
+  }
+
+  function readToken(mode, stream, state, inner) {
+    for (var i = 0; i < 10; i++) {
+      if (inner) inner[0] = CodeMirror.innerMode(mode, state).mode;
+      var style = mode.token(stream, state);
+      if (stream.pos > stream.start) return style;
+    }
+    throw new Error("Mode " + mode.name + " failed to advance stream.");
+  }
+
+  // Utility for getTokenAt and getLineTokens
+  function takeToken(cm, pos, precise, asArray) {
+    function getObj(copy) {
+      return {start: stream.start, end: stream.pos,
+              string: stream.current(),
+              type: style || null,
+              state: copy ? copyState(doc.mode, state) : state};
+    }
+
+    var doc = cm.doc, mode = doc.mode, style;
+    pos = clipPos(doc, pos);
+    var line = getLine(doc, pos.line), state = getStateBefore(cm, pos.line, precise);
+    var stream = new StringStream(line.text, cm.options.tabSize), tokens;
+    if (asArray) tokens = [];
+    while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
+      stream.start = stream.pos;
+      style = readToken(mode, stream, state);
+      if (asArray) tokens.push(getObj(true));
+    }
+    return asArray ? tokens : getObj();
+  }
+
+  // Run the given mode's parser over a line, calling f for each token.
+  function runMode(cm, text, mode, state, f, lineClasses, forceToEnd) {
+    var flattenSpans = mode.flattenSpans;
+    if (flattenSpans == null) flattenSpans = cm.options.flattenSpans;
+    var curStart = 0, curStyle = null;
+    var stream = new StringStream(text, cm.options.tabSize), style;
+    var inner = cm.options.addModeClass && [null];
+    if (text == "") extractLineClasses(callBlankLine(mode, state), lineClasses);
+    while (!stream.eol()) {
+      if (stream.pos > cm.options.maxHighlightLength) {
+        flattenSpans = false;
+        if (forceToEnd) processLine(cm, text, state, stream.pos);
+        stream.pos = text.length;
+        style = null;
+      } else {
+        style = extractLineClasses(readToken(mode, stream, state, inner), lineClasses);
+      }
+      if (inner) {
+        var mName = inner[0].name;
+        if (mName) style = "m-" + (style ? mName + " " + style : mName);
+      }
+      if (!flattenSpans || curStyle != style) {
+        while (curStart < stream.start) {
+          curStart = Math.min(stream.start, curStart + 50000);
+          f(curStart, curStyle);
+        }
+        curStyle = style;
+      }
+      stream.start = stream.pos;
+    }
+    while (curStart < stream.pos) {
+      // Webkit seems to refuse to render text nodes longer than 57444 characters
+      var pos = Math.min(stream.pos, curStart + 50000);
+      f(pos, curStyle);
+      curStart = pos;
+    }
+  }
+
+  // Compute a style array (an array starting with a mode generation
+  // -- for invalidation -- followed by pairs of end positions and
+  // style strings), which is used to highlight the tokens on the
+  // line.
+  function highlightLine(cm, line, state, forceToEnd) {
+    // A styles array always starts with a number identifying the
+    // mode/overlays that it is based on (for easy invalidation).
+    var st = [cm.state.modeGen], lineClasses = {};
+    // Compute the base array of styles
+    runMode(cm, line.text, cm.doc.mode, state, function(end, style) {
+      st.push(end, style);
+    }, lineClasses, forceToEnd);
+
+    // Run overlays, adjust style array.
+    for (var o = 0; o < cm.state.overlays.length; ++o) {
+      var overlay = cm.state.overlays[o], i = 1, at = 0;
+      runMode(cm, line.text, overlay.mode, true, function(end, style) {
+        var start = i;
+        // Ensure there's a token end at the current position, and that i points at it
+        while (at < end) {
+          var i_end = st[i];
+          if (i_end > end)
+            st.splice(i, 1, end, st[i+1], i_end);
+          i += 2;
+          at = Math.min(end, i_end);
+        }
+        if (!style) return;
+        if (overlay.opaque) {
+          st.splice(start, i - start, end, "cm-overlay " + style);
+          i = start + 2;
+        } else {
+          for (; start < i; start += 2) {
+            var cur = st[start+1];
+            st[start+1] = (cur ? cur + " " : "") + "cm-overlay " + style;
+          }
+        }
+      }, lineClasses);
+    }
+
+    return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null};
+  }
+
+  function getLineStyles(cm, line, updateFrontier) {
+    if (!line.styles || line.styles[0] != cm.state.modeGen) {
+      var result = highlightLine(cm, line, line.stateAfter = getStateBefore(cm, lineNo(line)));
+      line.styles = result.styles;
+      if (result.classes) line.styleClasses = result.classes;
+      else if (line.styleClasses) line.styleClasses = null;
+      if (updateFrontier === cm.doc.frontier) cm.doc.frontier++;
+    }
+    return line.styles;
+  }
+
+  // Lightweight form of highlight -- proceed over this line and
+  // update state, but don't save a style array. Used for lines that
+  // aren't currently visible.
+  function processLine(cm, text, state, startAt) {
+    var mode = cm.doc.mode;
+    var stream = new StringStream(text, cm.options.tabSize);
+    stream.start = stream.pos = startAt || 0;
+    if (text == "") callBlankLine(mode, state);
+    while (!stream.eol() && stream.pos <= cm.options.maxHighlightLength) {
+      readToken(mode, stream, state);
+      stream.start = stream.pos;
+    }
+  }
+
+  // Convert a style as returned by a mode (either null, or a string
+  // containing one or more styles) to a CSS style. This is cached,
+  // and also looks for line-wide styles.
+  var styleToClassCache = {}, styleToClassCacheWithMode = {};
+  function interpretTokenStyle(style, options) {
+    if (!style || /^\s*$/.test(style)) return null;
+    var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache;
+    return cache[style] ||
+      (cache[style] = style.replace(/\S+/g, "cm-$&"));
+  }
+
+  // Render the DOM representation of the text of a line. Also builds
+  // up a 'line map', which points at the DOM nodes that represent
+  // specific stretches of text, and is used by the measuring code.
+  // The returned object contains the DOM node, this map, and
+  // information about line-wide styles that were set by the mode.
+  function buildLineContent(cm, lineView) {
+    // The padding-right forces the element to have a 'border', which
+    // is needed on Webkit to be able to get line-level bounding
+    // rectangles for it (in measureChar).
+    var content = elt("span", null, null, webkit ? "padding-right: .1px" : null);
+    var builder = {pre: elt("pre", [content], "CodeMirror-line"), content: content,
+                   col: 0, pos: 0, cm: cm,
+                   splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")};
+    lineView.measure = {};
+
+    // Iterate over the logical lines that make up this visual line.
+    for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
+      var line = i ? lineView.rest[i - 1] : lineView.line, order;
+      builder.pos = 0;
+      builder.addToken = buildToken;
+      // Optionally wire in some hacks into the token-rendering
+      // algorithm, to deal with browser quirks.
+      if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line)))
+        builder.addToken = buildTokenBadBidi(builder.addToken, order);
+      builder.map = [];
+      var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line);
+      insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate));
+      if (line.styleClasses) {
+        if (line.styleClasses.bgClass)
+          builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || "");
+        if (line.styleClasses.textClass)
+          builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || "");
+      }
+
+      // Ensure at least a single node is present, for measuring.
+      if (builder.map.length == 0)
+        builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure)));
+
+      // Store the map and a cache object for the current logical line
+      if (i == 0) {
+        lineView.measure.map = builder.map;
+        lineView.measure.cache = {};
+      } else {
+        (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map);
+        (lineView.measure.caches || (lineView.measure.caches = [])).push({});
+      }
+    }
+
+    // See issue #2901
+    if (webkit && /\bcm-tab\b/.test(builder.content.lastChild.className))
+      builder.content.className = "cm-tab-wrap-hack";
+
+    signal(cm, "renderLine", cm, lineView.line, builder.pre);
+    if (builder.pre.className)
+      builder.textClass = joinClasses(builder.pre.className, builder.textClass || "");
+
+    return builder;
+  }
+
+  function defaultSpecialCharPlaceholder(ch) {
+    var token = elt("span", "\u2022", "cm-invalidchar");
+    token.title = "\\u" + ch.charCodeAt(0).toString(16);
+    token.setAttribute("aria-label", token.title);
+    return token;
+  }
+
+  // Build up the DOM representation for a single token, and add it to
+  // the line map. Takes care to render special characters separately.
+  function buildToken(builder, text, style, startStyle, endStyle, title, css) {
+    if (!text) return;
+    var displayText = builder.splitSpaces ? text.replace(/ {3,}/g, splitSpaces) : text;
+    var special = builder.cm.state.specialChars, mustWrap = false;
+    if (!special.test(text)) {
+      builder.col += text.length;
+      var content = document.createTextNode(displayText);
+      builder.map.push(builder.pos, builder.pos + text.length, content);
+      if (ie && ie_version < 9) mustWrap = true;
+      builder.pos += text.length;
+    } else {
+      var content = document.createDocumentFragment(), pos = 0;
+      while (true) {
+        special.lastIndex = pos;
+        var m = special.exec(text);
+        var skipped = m ? m.index - pos : text.length - pos;
+        if (skipped) {
+          var txt = document.createTextNode(displayText.slice(pos, pos + skipped));
+          if (ie && ie_version < 9) content.appendChild(elt("span", [txt]));
+          else content.appendChild(txt);
+          builder.map.push(builder.pos, builder.pos + skipped, txt);
+          builder.col += skipped;
+          builder.pos += skipped;
+        }
+        if (!m) break;
+        pos += skipped + 1;
+        if (m[0] == "\t") {
+          var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize;
+          var txt = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"));
+          txt.setAttribute("role", "presentation");
+          txt.setAttribute("cm-text", "\t");
+          builder.col += tabWidth;
+        } else {
+          var txt = builder.cm.options.specialCharPlaceholder(m[0]);
+          txt.setAttribute("cm-text", m[0]);
+          if (ie && ie_version < 9) content.appendChild(elt("span", [txt]));
+          else content.appendChild(txt);
+          builder.col += 1;
+        }
+        builder.map.push(builder.pos, builder.pos + 1, txt);
+        builder.pos++;
+      }
+    }
+    if (style || startStyle || endStyle || mustWrap || css) {
+      var fullStyle = style || "";
+      if (startStyle) fullStyle += startStyle;
+      if (endStyle) fullStyle += endStyle;
+      var token = elt("span", [content], fullStyle, css);
+      if (title) token.title = title;
+      return builder.content.appendChild(token);
+    }
+    builder.content.appendChild(content);
+  }
+
+  function splitSpaces(old) {
+    var out = " ";
+    for (var i = 0; i < old.length - 2; ++i) out += i % 2 ? " " : "\u00a0";
+    out += " ";
+    return out;
+  }
+
+  // Work around nonsense dimensions being reported for stretches of
+  // right-to-left text.
+  function buildTokenBadBidi(inner, order) {
+    return function(builder, text, style, startStyle, endStyle, title, css) {
+      style = style ? style + " cm-force-border" : "cm-force-border";
+      var start = builder.pos, end = start + text.length;
+      for (;;) {
+        // Find the part that overlaps with the start of this text
+        for (var i = 0; i < order.length; i++) {
+          var part = order[i];
+          if (part.to > start && part.from <= start) break;
+        }
+        if (part.to >= end) return inner(builder, text, style, startStyle, endStyle, title, css);
+        inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css);
+        startStyle = null;
+        text = text.slice(part.to - start);
+        start = part.to;
+      }
+    };
+  }
+
+  function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
+    var widget = !ignoreWidget && marker.widgetNode;
+    if (widget) builder.map.push(builder.pos, builder.pos + size, widget);
+    if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {
+      if (!widget)
+        widget = builder.content.appendChild(document.createElement("span"));
+      widget.setAttribute("cm-marker", marker.id);
+    }
+    if (widget) {
+      builder.cm.display.input.setUneditable(widget);
+      builder.content.appendChild(widget);
+    }
+    builder.pos += size;
+  }
+
+  // Outputs a number of spans to make up a line, taking highlighting
+  // and marked text into account.
+  function insertLineContent(line, builder, styles) {
+    var spans = line.markedSpans, allText = line.text, at = 0;
+    if (!spans) {
+      for (var i = 1; i < styles.length; i+=2)
+        builder.addToken(builder, allText.slice(at, at = styles[i]), interpretTokenStyle(styles[i+1], builder.cm.options));
+      return;
+    }
+
+    var len = allText.length, pos = 0, i = 1, text = "", style, css;
+    var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed;
+    for (;;) {
+      if (nextChange == pos) { // Update current marker set
+        spanStyle = spanEndStyle = spanStartStyle = title = css = "";
+        collapsed = null; nextChange = Infinity;
+        var foundBookmarks = [];
+        for (var j = 0; j < spans.length; ++j) {
+          var sp = spans[j], m = sp.marker;
+          if (m.type == "bookmark" && sp.from == pos && m.widgetNode) {
+            foundBookmarks.push(m);
+          } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {
+            if (sp.to != null && sp.to != pos && nextChange > sp.to) {
+              nextChange = sp.to;
+              spanEndStyle = "";
+            }
+            if (m.className) spanStyle += " " + m.className;
+            if (m.css) css = m.css;
+            if (m.startStyle && sp.from == pos) spanStartStyle += " " + m.startStyle;
+            if (m.endStyle && sp.to == nextChange) spanEndStyle += " " + m.endStyle;
+            if (m.title && !title) title = m.title;
+            if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))
+              collapsed = sp;
+          } else if (sp.from > pos && nextChange > sp.from) {
+            nextChange = sp.from;
+          }
+        }
+        if (collapsed && (collapsed.from || 0) == pos) {
+          buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
+                             collapsed.marker, collapsed.from == null);
+          if (collapsed.to == null) return;
+          if (collapsed.to == pos) collapsed = false;
+        }
+        if (!collapsed && foundBookmarks.length) for (var j = 0; j < foundBookmarks.length; ++j)
+          buildCollapsedSpan(builder, 0, foundBookmarks[j]);
+      }
+      if (pos >= len) break;
+
+      var upto = Math.min(len, nextChange);
+      while (true) {
+        if (text) {
+          var end = pos + text.length;
+          if (!collapsed) {
+            var tokenText = end > upto ? text.slice(0, upto - pos) : text;
+            builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,
+                             spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css);
+          }
+          if (end >= upto) {text = text.slice(upto - pos); pos = upto; break;}
+          pos = end;
+          spanStartStyle = "";
+        }
+        text = allText.slice(at, at = styles[i++]);
+        style = interpretTokenStyle(styles[i++], builder.cm.options);
+      }
+    }
+  }
+
+  // DOCUMENT DATA STRUCTURE
+
+  // By default, updates that start and end at the beginning of a line
+  // are treated specially, in order to make the association of line
+  // widgets and marker elements with the text behave more intuitive.
+  function isWholeLineUpdate(doc, change) {
+    return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" &&
+      (!doc.cm || doc.cm.options.wholeLineUpdateBefore);
+  }
+
+  // Perform a change on the document data structure.
+  function updateDoc(doc, change, markedSpans, estimateHeight) {
+    function spansFor(n) {return markedSpans ? markedSpans[n] : null;}
+    function update(line, text, spans) {
+      updateLine(line, text, spans, estimateHeight);
+      signalLater(line, "change", line, change);
+    }
+    function linesFor(start, end) {
+      for (var i = start, result = []; i < end; ++i)
+        result.push(new Line(text[i], spansFor(i), estimateHeight));
+      return result;
+    }
+
+    var from = change.from, to = change.to, text = change.text;
+    var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line);
+    var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line;
+
+    // Adjust the line structure
+    if (change.full) {
+      doc.insert(0, linesFor(0, text.length));
+      doc.remove(text.length, doc.size - text.length);
+    } else if (isWholeLineUpdate(doc, change)) {
+      // This is a whole-line replace. Treated specially to make
+      // sure line objects move the way they are supposed to.
+      var added = linesFor(0, text.length - 1);
+      update(lastLine, lastLine.text, lastSpans);
+      if (nlines) doc.remove(from.line, nlines);
+      if (added.length) doc.insert(from.line, added);
+    } else if (firstLine == lastLine) {
+      if (text.length == 1) {
+        update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans);
+      } else {
+        var added = linesFor(1, text.length - 1);
+        added.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight));
+        update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));
+        doc.insert(from.line + 1, added);
+      }
+    } else if (text.length == 1) {
+      update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0));
+      doc.remove(from.line + 1, nlines);
+    } else {
+      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));
+      update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans);
+      var added = linesFor(1, text.length - 1);
+      if (nlines > 1) doc.remove(from.line + 1, nlines - 1);
+      doc.insert(from.line + 1, added);
+    }
+
+    signalLater(doc, "change", doc, change);
+  }
+
+  // The document is represented as a BTree consisting of leaves, with
+  // chunk of lines in them, and branches, with up to ten leaves or
+  // other branch nodes below them. The top node is always a branch
+  // node, and is the document object itself (meaning it has
+  // additional methods and properties).
+  //
+  // All nodes have parent links. The tree is used both to go from
+  // line numbers to line objects, and to go from objects to numbers.
+  // It also indexes by height, and is used to convert between height
+  // and line object, and to find the total height of the document.
+  //
+  // See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html
+
+  function LeafChunk(lines) {
+    this.lines = lines;
+    this.parent = null;
+    for (var i = 0, height = 0; i < lines.length; ++i) {
+      lines[i].parent = this;
+      height += lines[i].height;
+    }
+    this.height = height;
+  }
+
+  LeafChunk.prototype = {
+    chunkSize: function() { return this.lines.length; },
+    // Remove the n lines at offset 'at'.
+    removeInner: function(at, n) {
+      for (var i = at, e = at + n; i < e; ++i) {
+        var line = this.lines[i];
+        this.height -= line.height;
+        cleanUpLine(line);
+        signalLater(line, "delete");
+      }
+      this.lines.splice(at, n);
+    },
+    // Helper used to collapse a small branch into a single leaf.
+    collapse: function(lines) {
+      lines.push.apply(lines, this.lines);
+    },
+    // Insert the given array of lines at offset 'at', count them as
+    // having the given height.
+    insertInner: function(at, lines, height) {
+      this.height += height;
+      this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at));
+      for (var i = 0; i < lines.length; ++i) lines[i].parent = this;
+    },
+    // Used to iterate over a part of the tree.
+    iterN: function(at, n, op) {
+      for (var e = at + n; at < e; ++at)
+        if (op(this.lines[at])) return true;
+    }
+  };
+
+  function BranchChunk(children) {
+    this.children = children;
+    var size = 0, height = 0;
+    for (var i = 0; i < children.length; ++i) {
+      var ch = children[i];
+      size += ch.chunkSize(); height += ch.height;
+      ch.parent = this;
+    }
+    this.size = size;
+    this.height = height;
+    this.parent = null;
+  }
+
+  BranchChunk.prototype = {
+    chunkSize: function() { return this.size; },
+    removeInner: function(at, n) {
+      this.size -= n;
+      for (var i = 0; i < this.children.length; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at < sz) {
+          var rm = Math.min(n, sz - at), oldHeight = child.height;
+          child.removeInner(at, rm);
+          this.height -= oldHeight - child.height;
+          if (sz == rm) { this.children.splice(i--, 1); child.parent = null; }
+          if ((n -= rm) == 0) break;
+          at = 0;
+        } else at -= sz;
+      }
+      // If the result is smaller than 25 lines, ensure that it is a
+      // single leaf node.
+      if (this.size - n < 25 &&
+          (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
+        var lines = [];
+        this.collapse(lines);
+        this.children = [new LeafChunk(lines)];
+        this.children[0].parent = this;
+      }
+    },
+    collapse: function(lines) {
+      for (var i = 0; i < this.children.length; ++i) this.children[i].collapse(lines);
+    },
+    insertInner: function(at, lines, height) {
+      this.size += lines.length;
+      this.height += height;
+      for (var i = 0; i < this.children.length; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at <= sz) {
+          child.insertInner(at, lines, height);
+          if (child.lines && child.lines.length > 50) {
+            while (child.lines.length > 50) {
+              var spilled = child.lines.splice(child.lines.length - 25, 25);
+              var newleaf = new LeafChunk(spilled);
+              child.height -= newleaf.height;
+              this.children.splice(i + 1, 0, newleaf);
+              newleaf.parent = this;
+            }
+            this.maybeSpill();
+          }
+          break;
+        }
+        at -= sz;
+      }
+    },
+    // When a node has grown, check whether it should be split.
+    maybeSpill: function() {
+      if (this.children.length <= 10) return;
+      var me = this;
+      do {
+        var spilled = me.children.splice(me.children.length - 5, 5);
+        var sibling = new BranchChunk(spilled);
+        if (!me.parent) { // Become the parent node
+          var copy = new BranchChunk(me.children);
+          copy.parent = me;
+          me.children = [copy, sibling];
+          me = copy;
+        } else {
+          me.size -= sibling.size;
+          me.height -= sibling.height;
+          var myIndex = indexOf(me.parent.children, me);
+          me.parent.children.splice(myIndex + 1, 0, sibling);
+        }
+        sibling.parent = me.parent;
+      } while (me.children.length > 10);
+      me.parent.maybeSpill();
+    },
+    iterN: function(at, n, op) {
+      for (var i = 0; i < this.children.length; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at < sz) {
+          var used = Math.min(n, sz - at);
+          if (child.iterN(at, used, op)) return true;
+          if ((n -= used) == 0) break;
+          at = 0;
+        } else at -= sz;
+      }
+    }
+  };
+
+  var nextDocId = 0;
+  var Doc = CodeMirror.Doc = function(text, mode, firstLine) {
+    if (!(this instanceof Doc)) return new Doc(text, mode, firstLine);
+    if (firstLine == null) firstLine = 0;
+
+    BranchChunk.call(this, [new LeafChunk([new Line("", null)])]);
+    this.first = firstLine;
+    this.scrollTop = this.scrollLeft = 0;
+    this.cantEdit = false;
+    this.cleanGeneration = 1;
+    this.frontier = firstLine;
+    var start = Pos(firstLine, 0);
+    this.sel = simpleSelection(start);
+    this.history = new History(null);
+    this.id = ++nextDocId;
+    this.modeOption = mode;
+
+    if (typeof text == "string") text = splitLines(text);
+    updateDoc(this, {from: start, to: start, text: text});
+    setSelection(this, simpleSelection(start), sel_dontScroll);
+  };
+
+  Doc.prototype = createObj(BranchChunk.prototype, {
+    constructor: Doc,
+    // Iterate over the document. Supports two forms -- with only one
+    // argument, it calls that for each line in the document. With
+    // three, it iterates over the range given by the first two (with
+    // the second being non-inclusive).
+    iter: function(from, to, op) {
+      if (op) this.iterN(from - this.first, to - from, op);
+      else this.iterN(this.first, this.first + this.size, from);
+    },
+
+    // Non-public interface for adding and removing lines.
+    insert: function(at, lines) {
+      var height = 0;
+      for (var i = 0; i < lines.length; ++i) height += lines[i].height;
+      this.insertInner(at - this.first, lines, height);
+    },
+    remove: function(at, n) { this.removeInner(at - this.first, n); },
+
+    // From here, the methods are part of the public interface. Most
+    // are also available from CodeMirror (editor) instances.
+
+    getValue: function(lineSep) {
+      var lines = getLines(this, this.first, this.first + this.size);
+      if (lineSep === false) return lines;
+      return lines.join(lineSep || "\n");
+    },
+    setValue: docMethodOp(function(code) {
+      var top = Pos(this.first, 0), last = this.first + this.size - 1;
+      makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),
+                        text: splitLines(code), origin: "setValue", full: true}, true);
+      setSelection(this, simpleSelection(top));
+    }),
+    replaceRange: function(code, from, to, origin) {
+      from = clipPos(this, from);
+      to = to ? clipPos(this, to) : from;
+      replaceRange(this, code, from, to, origin);
+    },
+    getRange: function(from, to, lineSep) {
+      var lines = getBetween(this, clipPos(this, from), clipPos(this, to));
+      if (lineSep === false) return lines;
+      return lines.join(lineSep || "\n");
+    },
+
+    getLine: function(line) {var l = this.getLineHandle(line); return l && l.text;},
+
+    getLineHandle: function(line) {if (isLine(this, line)) return getLine(this, line);},
+    getLineNumber: function(line) {return lineNo(line);},
+
+    getLineHandleVisualStart: function(line) {
+      if (typeof line == "number") line = getLine(this, line);
+      return visualLine(line);
+    },
+
+    lineCount: function() {return this.size;},
+    firstLine: function() {return this.first;},
+    lastLine: function() {return this.first + this.size - 1;},
+
+    clipPos: function(pos) {return clipPos(this, pos);},
+
+    getCursor: function(start) {
+      var range = this.sel.primary(), pos;
+      if (start == null || start == "head") pos = range.head;
+      else if (start == "anchor") pos = range.anchor;
+      else if (start == "end" || start == "to" || start === false) pos = range.to();
+      else pos = range.from();
+      return pos;
+    },
+    listSelections: function() { return this.sel.ranges; },
+    somethingSelected: function() {return this.sel.somethingSelected();},
+
+    setCursor: docMethodOp(function(line, ch, options) {
+      setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options);
+    }),
+    setSelection: docMethodOp(function(anchor, head, options) {
+      setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options);
+    }),
+    extendSelection: docMethodOp(function(head, other, options) {
+      extendSelection(this, clipPos(this, head), other && clipPos(this, other), options);
+    }),
+    extendSelections: docMethodOp(function(heads, options) {
+      extendSelections(this, clipPosArray(this, heads, options));
+    }),
+    extendSelectionsBy: docMethodOp(function(f, options) {
+      extendSelections(this, map(this.sel.ranges, f), options);
+    }),
+    setSelections: docMethodOp(function(ranges, primary, options) {
+      if (!ranges.length) return;
+      for (var i = 0, out = []; i < ranges.length; i++)
+        out[i] = new Range(clipPos(this, ranges[i].anchor),
+                           clipPos(this, ranges[i].head));
+      if (primary == null) primary = Math.min(ranges.length - 1, this.sel.primIndex);
+      setSelection(this, normalizeSelection(out, primary), options);
+    }),
+    addSelection: docMethodOp(function(anchor, head, options) {
+      var ranges = this.sel.ranges.slice(0);
+      ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)));
+      setSelection(this, normalizeSelection(ranges, ranges.length - 1), options);
+    }),
+
+    getSelection: function(lineSep) {
+      var ranges = this.sel.ranges, lines;
+      for (var i = 0; i < ranges.length; i++) {
+        var sel = getBetween(this, ranges[i].from(), ranges[i].to());
+        lines = lines ? lines.concat(sel) : sel;
+      }
+      if (lineSep === false) return lines;
+      else return lines.join(lineSep || "\n");
+    },
+    getSelections: function(lineSep) {
+      var parts = [], ranges = this.sel.ranges;
+      for (var i = 0; i < ranges.length; i++) {
+        var sel = getBetween(this, ranges[i].from(), ranges[i].to());
+        if (lineSep !== false) sel = sel.join(lineSep || "\n");
+        parts[i] = sel;
+      }
+      return parts;
+    },
+    replaceSelection: function(code, collapse, origin) {
+      var dup = [];
+      for (var i = 0; i < this.sel.ranges.length; i++)
+        dup[i] = code;
+      this.replaceSelections(dup, collapse, origin || "+input");
+    },
+    replaceSelections: docMethodOp(function(code, collapse, origin) {
+      var changes = [], sel = this.sel;
+      for (var i = 0; i < sel.ranges.length; i++) {
+        var range = sel.ranges[i];
+        changes[i] = {from: range.from(), to: range.to(), text: splitLines(code[i]), origin: origin};
+      }
+      var newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse);
+      for (var i = changes.length - 1; i >= 0; i--)
+        makeChange(this, changes[i]);
+      if (newSel) setSelectionReplaceHistory(this, newSel);
+      else if (this.cm) ensureCursorVisible(this.cm);
+    }),
+    undo: docMethodOp(function() {makeChangeFromHistory(this, "undo");}),
+    redo: docMethodOp(function() {makeChangeFromHistory(this, "redo");}),
+    undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true);}),
+    redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true);}),
+
+    setExtending: function(val) {this.extend = val;},
+    getExtending: function() {return this.extend;},
+
+    historySize: function() {
+      var hist = this.history, done = 0, undone = 0;
+      for (var i = 0; i < hist.done.length; i++) if (!hist.done[i].ranges) ++done;
+      for (var i = 0; i < hist.undone.length; i++) if (!hist.undone[i].ranges) ++undone;
+      return {undo: done, redo: undone};
+    },
+    clearHistory: function() {this.history = new History(this.history.maxGeneration);},
+
+    markClean: function() {
+      this.cleanGeneration = this.changeGeneration(true);
+    },
+    changeGeneration: function(forceSplit) {
+      if (forceSplit)
+        this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null;
+      return this.history.generation;
+    },
+    isClean: function (gen) {
+      return this.history.generation == (gen || this.cleanGeneration);
+    },
+
+    getHistory: function() {
+      return {done: copyHistoryArray(this.history.done),
+              undone: copyHistoryArray(this.history.undone)};
+    },
+    setHistory: function(histData) {
+      var hist = this.history = new History(this.history.maxGeneration);
+      hist.done = copyHistoryArray(histData.done.slice(0), null, true);
+      hist.undone = copyHistoryArray(histData.undone.slice(0), null, true);
+    },
+
+    addLineClass: docMethodOp(function(handle, where, cls) {
+      return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function(line) {
+        var prop = where == "text" ? "textClass"
+                 : where == "background" ? "bgClass"
+                 : where == "gutter" ? "gutterClass" : "wrapClass";
+        if (!line[prop]) line[prop] = cls;
+        else if (classTest(cls).test(line[prop])) return false;
+        else line[prop] += " " + cls;
+        return true;
+      });
+    }),
+    removeLineClass: docMethodOp(function(handle, where, cls) {
+      return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function(line) {
+        var prop = where == "text" ? "textClass"
+                 : where == "background" ? "bgClass"
+                 : where == "gutter" ? "gutterClass" : "wrapClass";
+        var cur = line[prop];
+        if (!cur) return false;
+        else if (cls == null) line[prop] = null;
+        else {
+          var found = cur.match(classTest(cls));
+          if (!found) return false;
+          var end = found.index + found[0].length;
+          line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null;
+        }
+        return true;
+      });
+    }),
+
+    addLineWidget: docMethodOp(function(handle, node, options) {
+      return addLineWidget(this, handle, node, options);
+    }),
+    removeLineWidget: function(widget) { widget.clear(); },
+
+    markText: function(from, to, options) {
+      return markText(this, clipPos(this, from), clipPos(this, to), options, "range");
+    },
+    setBookmark: function(pos, options) {
+      var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),
+                      insertLeft: options && options.insertLeft,
+                      clearWhenEmpty: false, shared: options && options.shared,
+                      handleMouseEvents: options && options.handleMouseEvents};
+      pos = clipPos(this, pos);
+      return markText(this, pos, pos, realOpts, "bookmark");
+    },
+    findMarksAt: function(pos) {
+      pos = clipPos(this, pos);
+      var markers = [], spans = getLine(this, pos.line).markedSpans;
+      if (spans) for (var i = 0; i < spans.length; ++i) {
+        var span = spans[i];
+        if ((span.from == null || span.from <= pos.ch) &&
+            (span.to == null || span.to >= pos.ch))
+          markers.push(span.marker.parent || span.marker);
+      }
+      return markers;
+    },
+    findMarks: function(from, to, filter) {
+      from = clipPos(this, from); to = clipPos(this, to);
+      var found = [], lineNo = from.line;
+      this.iter(from.line, to.line + 1, function(line) {
+        var spans = line.markedSpans;
+        if (spans) for (var i = 0; i < spans.length; i++) {
+          var span = spans[i];
+          if (!(lineNo == from.line && from.ch > span.to ||
+                span.from == null && lineNo != from.line||
+                lineNo == to.line && span.from > to.ch) &&
+              (!filter || filter(span.marker)))
+            found.push(span.marker.parent || span.marker);
+        }
+        ++lineNo;
+      });
+      return found;
+    },
+    getAllMarks: function() {
+      var markers = [];
+      this.iter(function(line) {
+        var sps = line.markedSpans;
+        if (sps) for (var i = 0; i < sps.length; ++i)
+          if (sps[i].from != null) markers.push(sps[i].marker);
+      });
+      return markers;
+    },
+
+    posFromIndex: function(off) {
+      var ch, lineNo = this.first;
+      this.iter(function(line) {
+        var sz = line.text.length + 1;
+        if (sz > off) { ch = off; return true; }
+        off -= sz;
+        ++lineNo;
+      });
+      return clipPos(this, Pos(lineNo, ch));
+    },
+    indexFromPos: function (coords) {
+      coords = clipPos(this, coords);
+      var index = coords.ch;
+      if (coords.line < this.first || coords.ch < 0) return 0;
+      this.iter(this.first, coords.line, function (line) {
+        index += line.text.length + 1;
+      });
+      return index;
+    },
+
+    copy: function(copyHistory) {
+      var doc = new Doc(getLines(this, this.first, this.first + this.size), this.modeOption, this.first);
+      doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft;
+      doc.sel = this.sel;
+      doc.extend = false;
+      if (copyHistory) {
+        doc.history.undoDepth = this.history.undoDepth;
+        doc.setHistory(this.getHistory());
+      }
+      return doc;
+    },
+
+    linkedDoc: function(options) {
+      if (!options) options = {};
+      var from = this.first, to = this.first + this.size;
+      if (options.from != null && options.from > from) from = options.from;
+      if (options.to != null && options.to < to) to = options.to;
+      var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from);
+      if (options.sharedHist) copy.history = this.history;
+      (this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist});
+      copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}];
+      copySharedMarkers(copy, findSharedMarkers(this));
+      return copy;
+    },
+    unlinkDoc: function(other) {
+      if (other instanceof CodeMirror) other = other.doc;
+      if (this.linked) for (var i = 0; i < this.linked.length; ++i) {
+        var link = this.linked[i];
+        if (link.doc != other) continue;
+        this.linked.splice(i, 1);
+        other.unlinkDoc(this);
+        detachSharedMarkers(findSharedMarkers(this));
+        break;
+      }
+      // If the histories were shared, split them again
+      if (other.history == this.history) {
+        var splitIds = [other.id];
+        linkedDocs(other, function(doc) {splitIds.push(doc.id);}, true);
+        other.history = new History(null);
+        other.history.done = copyHistoryArray(this.history.done, splitIds);
+        other.history.undone = copyHistoryArray(this.history.undone, splitIds);
+      }
+    },
+    iterLinkedDocs: function(f) {linkedDocs(this, f);},
+
+    getMode: function() {return this.mode;},
+    getEditor: function() {return this.cm;}
+  });
+
+  // Public alias.
+  Doc.prototype.eachLine = Doc.prototype.iter;
+
+  // Set up methods on CodeMirror's prototype to redirect to the editor's document.
+  var dontDelegate = "iter insert remove copy getEditor constructor".split(" ");
+  for (var prop in Doc.prototype) if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)
+    CodeMirror.prototype[prop] = (function(method) {
+      return function() {return method.apply(this.doc, arguments);};
+    })(Doc.prototype[prop]);
+
+  eventMixin(Doc);
+
+  // Call f for all linked documents.
+  function linkedDocs(doc, f, sharedHistOnly) {
+    function propagate(doc, skip, sharedHist) {
+      if (doc.linked) for (var i = 0; i < doc.linked.length; ++i) {
+        var rel = doc.linked[i];
+        if (rel.doc == skip) continue;
+        var shared = sharedHist && rel.sharedHist;
+        if (sharedHistOnly && !shared) continue;
+        f(rel.doc, shared);
+        propagate(rel.doc, doc, shared);
+      }
+    }
+    propagate(doc, null, true);
+  }
+
+  // Attach a document to an editor.
+  function attachDoc(cm, doc) {
+    if (doc.cm) throw new Error("This document is already in use.");
+    cm.doc = doc;
+    doc.cm = cm;
+    estimateLineHeights(cm);
+    loadMode(cm);
+    if (!cm.options.lineWrapping) findMaxLine(cm);
+    cm.options.mode = doc.modeOption;
+    regChange(cm);
+  }
+
+  // LINE UTILITIES
+
+  // Find the line object corresponding to the given line number.
+  function getLine(doc, n) {
+    n -= doc.first;
+    if (n < 0 || n >= doc.size) throw new Error("There is no line " + (n + doc.first) + " in the document.");
+    for (var chunk = doc; !chunk.lines;) {
+      for (var i = 0;; ++i) {
+        var child = chunk.children[i], sz = child.chunkSize();
+        if (n < sz) { chunk = child; break; }
+        n -= sz;
+      }
+    }
+    return chunk.lines[n];
+  }
+
+  // Get the part of a document between two positions, as an array of
+  // strings.
+  function getBetween(doc, start, end) {
+    var out = [], n = start.line;
+    doc.iter(start.line, end.line + 1, function(line) {
+      var text = line.text;
+      if (n == end.line) text = text.slice(0, end.ch);
+      if (n == start.line) text = text.slice(start.ch);
+      out.push(text);
+      ++n;
+    });
+    return out;
+  }
+  // Get the lines between from and to, as array of strings.
+  function getLines(doc, from, to) {
+    var out = [];
+    doc.iter(from, to, function(line) { out.push(line.text); });
+    return out;
+  }
+
+  // Update the height of a line, propagating the height change
+  // upwards to parent nodes.
+  function updateLineHeight(line, height) {
+    var diff = height - line.height;
+    if (diff) for (var n = line; n; n = n.parent) n.height += diff;
+  }
+
+  // Given a line object, find its line number by walking up through
+  // its parent links.
+  function lineNo(line) {
+    if (line.parent == null) return null;
+    var cur = line.parent, no = indexOf(cur.lines, line);
+    for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
+      for (var i = 0;; ++i) {
+        if (chunk.children[i] == cur) break;
+        no += chunk.children[i].chunkSize();
+      }
+    }
+    return no + cur.first;
+  }
+
+  // Find the line at the given vertical position, using the height
+  // information in the document tree.
+  function lineAtHeight(chunk, h) {
+    var n = chunk.first;
+    outer: do {
+      for (var i = 0; i < chunk.children.length; ++i) {
+        var child = chunk.children[i], ch = child.height;
+        if (h < ch) { chunk = child; continue outer; }
+        h -= ch;
+        n += child.chunkSize();
+      }
+      return n;
+    } while (!chunk.lines);
+    for (var i = 0; i < chunk.lines.length; ++i) {
+      var line = chunk.lines[i], lh = line.height;
+      if (h < lh) break;
+      h -= lh;
+    }
+    return n + i;
+  }
+
+
+  // Find the height above the given line.
+  function heightAtLine(lineObj) {
+    lineObj = visualLine(lineObj);
+
+    var h = 0, chunk = lineObj.parent;
+    for (var i = 0; i < chunk.lines.length; ++i) {
+      var line = chunk.lines[i];
+      if (line == lineObj) break;
+      else h += line.height;
+    }
+    for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {
+      for (var i = 0; i < p.children.length; ++i) {
+        var cur = p.children[i];
+        if (cur == chunk) break;
+        else h += cur.height;
+      }
+    }
+    return h;
+  }
+
+  // Get the bidi ordering for the given line (and cache it). Returns
+  // false for lines that are fully left-to-right, and an array of
+  // BidiSpan objects otherwise.
+  function getOrder(line) {
+    var order = line.order;
+    if (order == null) order = line.order = bidiOrdering(line.text);
+    return order;
+  }
+
+  // HISTORY
+
+  function History(startGen) {
+    // Arrays of change events and selections. Doing something adds an
+    // event to done and clears undo. Undoing moves events from done
+    // to undone, redoing moves them in the other direction.
+    this.done = []; this.undone = [];
+    this.undoDepth = Infinity;
+    // Used to track when changes can be merged into a single undo
+    // event
+    this.lastModTime = this.lastSelTime = 0;
+    this.lastOp = this.lastSelOp = null;
+    this.lastOrigin = this.lastSelOrigin = null;
+    // Used by the isClean() method
+    this.generation = this.maxGeneration = startGen || 1;
+  }
+
+  // Create a history change event from an updateDoc-style change
+  // object.
+  function historyChangeFromChange(doc, change) {
+    var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)};
+    attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);
+    linkedDocs(doc, function(doc) {attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);}, true);
+    return histChange;
+  }
+
+  // Pop all selection events off the end of a history array. Stop at
+  // a change event.
+  function clearSelectionEvents(array) {
+    while (array.length) {
+      var last = lst(array);
+      if (last.ranges) array.pop();
+      else break;
+    }
+  }
+
+  // Find the top change event in the history. Pop off selection
+  // events that are in the way.
+  function lastChangeEvent(hist, force) {
+    if (force) {
+      clearSelectionEvents(hist.done);
+      return lst(hist.done);
+    } else if (hist.done.length && !lst(hist.done).ranges) {
+      return lst(hist.done);
+    } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {
+      hist.done.pop();
+      return lst(hist.done);
+    }
+  }
+
+  // Register a change in the history. Merges changes that are within
+  // a single operation, ore are close together with an origin that
+  // allows merging (starting with "+") into a single event.
+  function addChangeToHistory(doc, change, selAfter, opId) {
+    var hist = doc.history;
+    hist.undone.length = 0;
+    var time = +new Date, cur;
+
+    if ((hist.lastOp == opId ||
+         hist.lastOrigin == change.origin && change.origin &&
+         ((change.origin.charAt(0) == "+" && doc.cm && hist.lastModTime > time - doc.cm.options.historyEventDelay) ||
+          change.origin.charAt(0) == "*")) &&
+        (cur = lastChangeEvent(hist, hist.lastOp == opId))) {
+      // Merge this change into the last event
+      var last = lst(cur.changes);
+      if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {
+        // Optimized case for simple insertion -- don't want to add
+        // new changesets for every character typed
+        last.to = changeEnd(change);
+      } else {
+        // Add new sub-event
+        cur.changes.push(historyChangeFromChange(doc, change));
+      }
+    } else {
+      // Can not be merged, start a new event.
+      var before = lst(hist.done);
+      if (!before || !before.ranges)
+        pushSelectionToHistory(doc.sel, hist.done);
+      cur = {changes: [historyChangeFromChange(doc, change)],
+             generation: hist.generation};
+      hist.done.push(cur);
+      while (hist.done.length > hist.undoDepth) {
+        hist.done.shift();
+        if (!hist.done[0].ranges) hist.done.shift();
+      }
+    }
+    hist.done.push(selAfter);
+    hist.generation = ++hist.maxGeneration;
+    hist.lastModTime = hist.lastSelTime = time;
+    hist.lastOp = hist.lastSelOp = opId;
+    hist.lastOrigin = hist.lastSelOrigin = change.origin;
+
+    if (!last) signal(doc, "historyAdded");
+  }
+
+  function selectionEventCanBeMerged(doc, origin, prev, sel) {
+    var ch = origin.charAt(0);
+    return ch == "*" ||
+      ch == "+" &&
+      prev.ranges.length == sel.ranges.length &&
+      prev.somethingSelected() == sel.somethingSelected() &&
+      new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500);
+  }
+
+  // Called whenever the selection changes, sets the new selection as
+  // the pending selection in the history, and pushes the old pending
+  // selection into the 'done' array when it was significantly
+  // different (in number of selected ranges, emptiness, or time).
+  function addSelectionToHistory(doc, sel, opId, options) {
+    var hist = doc.history, origin = options && options.origin;
+
+    // A new event is started when the previous origin does not match
+    // the current, or the origins don't allow matching. Origins
+    // starting with * are always merged, those starting with + are
+    // merged when similar and close together in time.
+    if (opId == hist.lastSelOp ||
+        (origin && hist.lastSelOrigin == origin &&
+         (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||
+          selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))
+      hist.done[hist.done.length - 1] = sel;
+    else
+      pushSelectionToHistory(sel, hist.done);
+
+    hist.lastSelTime = +new Date;
+    hist.lastSelOrigin = origin;
+    hist.lastSelOp = opId;
+    if (options && options.clearRedo !== false)
+      clearSelectionEvents(hist.undone);
+  }
+
+  function pushSelectionToHistory(sel, dest) {
+    var top = lst(dest);
+    if (!(top && top.ranges && top.equals(sel)))
+      dest.push(sel);
+  }
+
+  // Used to store marked span information in the history.
+  function attachLocalSpans(doc, change, from, to) {
+    var existing = change["spans_" + doc.id], n = 0;
+    doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function(line) {
+      if (line.markedSpans)
+        (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans;
+      ++n;
+    });
+  }
+
+  // When un/re-doing restores text containing marked spans, those
+  // that have been explicitly cleared should not be restored.
+  function removeClearedSpans(spans) {
+    if (!spans) return null;
+    for (var i = 0, out; i < spans.length; ++i) {
+      if (spans[i].marker.explicitlyCleared) { if (!out) out = spans.slice(0, i); }
+      else if (out) out.push(spans[i]);
+    }
+    return !out ? spans : out.length ? out : null;
+  }
+
+  // Retrieve and filter the old marked spans stored in a change event.
+  function getOldSpans(doc, change) {
+    var found = change["spans_" + doc.id];
+    if (!found) return null;
+    for (var i = 0, nw = []; i < change.text.length; ++i)
+      nw.push(removeClearedSpans(found[i]));
+    return nw;
+  }
+
+  // Used both to provide a JSON-safe object in .getHistory, and, when
+  // detaching a document, to split the history in two
+  function copyHistoryArray(events, newGroup, instantiateSel) {
+    for (var i = 0, copy = []; i < events.length; ++i) {
+      var event = events[i];
+      if (event.ranges) {
+        copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event);
+        continue;
+      }
+      var changes = event.changes, newChanges = [];
+      copy.push({changes: newChanges});
+      for (var j = 0; j < changes.length; ++j) {
+        var change = changes[j], m;
+        newChanges.push({from: change.from, to: change.to, text: change.text});
+        if (newGroup) for (var prop in change) if (m = prop.match(/^spans_(\d+)$/)) {
+          if (indexOf(newGroup, Number(m[1])) > -1) {
+            lst(newChanges)[prop] = change[prop];
+            delete change[prop];
+          }
+        }
+      }
+    }
+    return copy;
+  }
+
+  // Rebasing/resetting history to deal with externally-sourced changes
+
+  function rebaseHistSelSingle(pos, from, to, diff) {
+    if (to < pos.line) {
+      pos.line += diff;
+    } else if (from < pos.line) {
+      pos.line = from;
+      pos.ch = 0;
+    }
+  }
+
+  // Tries to rebase an array of history events given a change in the
+  // document. If the change touches the same lines as the event, the
+  // event, and everything 'behind' it, is discarded. If the change is
+  // before the event, the event's positions are updated. Uses a
+  // copy-on-write scheme for the positions, to avoid having to
+  // reallocate them all on every rebase, but also avoid problems with
+  // shared position objects being unsafely updated.
+  function rebaseHistArray(array, from, to, diff) {
+    for (var i = 0; i < array.length; ++i) {
+      var sub = array[i], ok = true;
+      if (sub.ranges) {
+        if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true; }
+        for (var j = 0; j < sub.ranges.length; j++) {
+          rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff);
+          rebaseHistSelSingle(sub.ranges[j].head, from, to, diff);
+        }
+        continue;
+      }
+      for (var j = 0; j < sub.changes.length; ++j) {
+        var cur = sub.changes[j];
+        if (to < cur.from.line) {
+          cur.from = Pos(cur.from.line + diff, cur.from.ch);
+          cur.to = Pos(cur.to.line + diff, cur.to.ch);
+        } else if (from <= cur.to.line) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok) {
+        array.splice(0, i + 1);
+        i = 0;
+      }
+    }
+  }
+
+  function rebaseHist(hist, change) {
+    var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1;
+    rebaseHistArray(hist.done, from, to, diff);
+    rebaseHistArray(hist.undone, from, to, diff);
+  }
+
+  // EVENT UTILITIES
+
+  // Due to the fact that we still support jurassic IE versions, some
+  // compatibility wrappers are needed.
+
+  var e_preventDefault = CodeMirror.e_preventDefault = function(e) {
+    if (e.preventDefault) e.preventDefault();
+    else e.returnValue = false;
+  };
+  var e_stopPropagation = CodeMirror.e_stopPropagation = function(e) {
+    if (e.stopPropagation) e.stopPropagation();
+    else e.cancelBubble = true;
+  };
+  function e_defaultPrevented(e) {
+    return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false;
+  }
+  var e_stop = CodeMirror.e_stop = function(e) {e_preventDefault(e); e_stopPropagation(e);};
+
+  function e_target(e) {return e.target || e.srcElement;}
+  function e_button(e) {
+    var b = e.which;
+    if (b == null) {
+      if (e.button & 1) b = 1;
+      else if (e.button & 2) b = 3;
+      else if (e.button & 4) b = 2;
+    }
+    if (mac && e.ctrlKey && b == 1) b = 3;
+    return b;
+  }
+
+  // EVENT HANDLING
+
+  // Lightweight event framework. on/off also work on DOM nodes,
+  // registering native DOM handlers.
+
+  var on = CodeMirror.on = function(emitter, type, f) {
+    if (emitter.addEventListener)
+      emitter.addEventListener(type, f, false);
+    else if (emitter.attachEvent)
+      emitter.attachEvent("on" + type, f);
+    else {
+      var map = emitter._handlers || (emitter._handlers = {});
+      var arr = map[type] || (map[type] = []);
+      arr.push(f);
+    }
+  };
+
+  var off = CodeMirror.off = function(emitter, type, f) {
+    if (emitter.removeEventListener)
+      emitter.removeEventListener(type, f, false);
+    else if (emitter.detachEvent)
+      emitter.detachEvent("on" + type, f);
+    else {
+      var arr = emitter._handlers && emitter._handlers[type];
+      if (!arr) return;
+      for (var i = 0; i < arr.length; ++i)
+        if (arr[i] == f) { arr.splice(i, 1); break; }
+    }
+  };
+
+  var signal = CodeMirror.signal = function(emitter, type /*, values...*/) {
+    var arr = emitter._handlers && emitter._handlers[type];
+    if (!arr) return;
+    var args = Array.prototype.slice.call(arguments, 2);
+    for (var i = 0; i < arr.length; ++i) arr[i].apply(null, args);
+  };
+
+  var orphanDelayedCallbacks = null;
+
+  // Often, we want to signal events at a point where we are in the
+  // middle of some work, but don't want the handler to start calling
+  // other methods on the editor, which might be in an inconsistent
+  // state or simply not expect any other events to happen.
+  // signalLater looks whether there are any handlers, and schedules
+  // them to be executed when the last operation ends, or, if no
+  // operation is active, when a timeout fires.
+  function signalLater(emitter, type /*, values...*/) {
+    var arr = emitter._handlers && emitter._handlers[type];
+    if (!arr) return;
+    var args = Array.prototype.slice.call(arguments, 2), list;
+    if (operationGroup) {
+      list = operationGroup.delayedCallbacks;
+    } else if (orphanDelayedCallbacks) {
+      list = orphanDelayedCallbacks;
+    } else {
+      list = orphanDelayedCallbacks = [];
+      setTimeout(fireOrphanDelayed, 0);
+    }
+    function bnd(f) {return function(){f.apply(null, args);};};
+    for (var i = 0; i < arr.length; ++i)
+      list.push(bnd(arr[i]));
+  }
+
+  function fireOrphanDelayed() {
+    var delayed = orphanDelayedCallbacks;
+    orphanDelayedCallbacks = null;
+    for (var i = 0; i < delayed.length; ++i) delayed[i]();
+  }
+
+  // The DOM events that CodeMirror handles can be overridden by
+  // registering a (non-DOM) handler on the editor for the event name,
+  // and preventDefault-ing the event in that handler.
+  function signalDOMEvent(cm, e, override) {
+    if (typeof e == "string")
+      e = {type: e, preventDefault: function() { this.defaultPrevented = true; }};
+    signal(cm, override || e.type, cm, e);
+    return e_defaultPrevented(e) || e.codemirrorIgnore;
+  }
+
+  function signalCursorActivity(cm) {
+    var arr = cm._handlers && cm._handlers.cursorActivity;
+    if (!arr) return;
+    var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []);
+    for (var i = 0; i < arr.length; ++i) if (indexOf(set, arr[i]) == -1)
+      set.push(arr[i]);
+  }
+
+  function hasHandler(emitter, type) {
+    var arr = emitter._handlers && emitter._handlers[type];
+    return arr && arr.length > 0;
+  }
+
+  // Add on and off methods to a constructor's prototype, to make
+  // registering events on such objects more convenient.
+  function eventMixin(ctor) {
+    ctor.prototype.on = function(type, f) {on(this, type, f);};
+    ctor.prototype.off = function(type, f) {off(this, type, f);};
+  }
+
+  // MISC UTILITIES
+
+  // Number of pixels added to scroller and sizer to hide scrollbar
+  var scrollerGap = 30;
+
+  // Returned or thrown by various protocols to signal 'I'm not
+  // handling this'.
+  var Pass = CodeMirror.Pass = {toString: function(){return "CodeMirror.Pass";}};
+
+  // Reused option objects for setSelection & friends
+  var sel_dontScroll = {scroll: false}, sel_mouse = {origin: "*mouse"}, sel_move = {origin: "+move"};
+
+  function Delayed() {this.id = null;}
+  Delayed.prototype.set = function(ms, f) {
+    clearTimeout(this.id);
+    this.id = setTimeout(f, ms);
+  };
+
+  // Counts the column offset in a string, taking tabs into account.
+  // Used mostly to find indentation.
+  var countColumn = CodeMirror.countColumn = function(string, end, tabSize, startIndex, startValue) {
+    if (end == null) {
+      end = string.search(/[^\s\u00a0]/);
+      if (end == -1) end = string.length;
+    }
+    for (var i = startIndex || 0, n = startValue || 0;;) {
+      var nextTab = string.indexOf("\t", i);
+      if (nextTab < 0 || nextTab >= end)
+        return n + (end - i);
+      n += nextTab - i;
+      n += tabSize - (n % tabSize);
+      i = nextTab + 1;
+    }
+  };
+
+  // The inverse of countColumn -- find the offset that corresponds to
+  // a particular column.
+  function findColumn(string, goal, tabSize) {
+    for (var pos = 0, col = 0;;) {
+      var nextTab = string.indexOf("\t", pos);
+      if (nextTab == -1) nextTab = string.length;
+      var skipped = nextTab - pos;
+      if (nextTab == string.length || col + skipped >= goal)
+        return pos + Math.min(skipped, goal - col);
+      col += nextTab - pos;
+      col += tabSize - (col % tabSize);
+      pos = nextTab + 1;
+      if (col >= goal) return pos;
+    }
+  }
+
+  var spaceStrs = [""];
+  function spaceStr(n) {
+    while (spaceStrs.length <= n)
+      spaceStrs.push(lst(spaceStrs) + " ");
+    return spaceStrs[n];
+  }
+
+  function lst(arr) { return arr[arr.length-1]; }
+
+  var selectInput = function(node) { node.select(); };
+  if (ios) // Mobile Safari apparently has a bug where select() is broken.
+    selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length; };
+  else if (ie) // Suppress mysterious IE10 errors
+    selectInput = function(node) { try { node.select(); } catch(_e) {} };
+
+  function indexOf(array, elt) {
+    for (var i = 0; i < array.length; ++i)
+      if (array[i] == elt) return i;
+    return -1;
+  }
+  function map(array, f) {
+    var out = [];
+    for (var i = 0; i < array.length; i++) out[i] = f(array[i], i);
+    return out;
+  }
+
+  function nothing() {}
+
+  function createObj(base, props) {
+    var inst;
+    if (Object.create) {
+      inst = Object.create(base);
+    } else {
+      nothing.prototype = base;
+      inst = new nothing();
+    }
+    if (props) copyObj(props, inst);
+    return inst;
+  };
+
+  function copyObj(obj, target, overwrite) {
+    if (!target) target = {};
+    for (var prop in obj)
+      if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
+        target[prop] = obj[prop];
+    return target;
+  }
+
+  function bind(f) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    return function(){return f.apply(null, args);};
+  }
+
+  var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
+  var isWordCharBasic = CodeMirror.isWordChar = function(ch) {
+    return /\w/.test(ch) || ch > "\x80" &&
+      (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch));
+  };
+  function isWordChar(ch, helper) {
+    if (!helper) return isWordCharBasic(ch);
+    if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) return true;
+    return helper.test(ch);
+  }
+
+  function isEmpty(obj) {
+    for (var n in obj) if (obj.hasOwnProperty(n) && obj[n]) return false;
+    return true;
+  }
+
+  // Extending unicode characters. A series of a non-extending char +
+  // any number of extending chars is treated as a single unit as far
+  // as editing and measuring is concerned. This is not fully correct,
+  // since some scripts/fonts/browsers also treat other configurations
+  // of code points as a group.
+  var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/;
+  function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch); }
+
+  // DOM UTILITIES
+
+  function elt(tag, content, className, style) {
+    var e = document.createElement(tag);
+    if (className) e.className = className;
+    if (style) e.style.cssText = style;
+    if (typeof content == "string") e.appendChild(document.createTextNode(content));
+    else if (content) for (var i = 0; i < content.length; ++i) e.appendChild(content[i]);
+    return e;
+  }
+
+  var range;
+  if (document.createRange) range = function(node, start, end, endNode) {
+    var r = document.createRange();
+    r.setEnd(endNode || node, end);
+    r.setStart(node, start);
+    return r;
+  };
+  else range = function(node, start, end) {
+    var r = document.body.createTextRange();
+    try { r.moveToElementText(node.parentNode); }
+    catch(e) { return r; }
+    r.collapse(true);
+    r.moveEnd("character", end);
+    r.moveStart("character", start);
+    return r;
+  };
+
+  function removeChildren(e) {
+    for (var count = e.childNodes.length; count > 0; --count)
+      e.removeChild(e.firstChild);
+    return e;
+  }
+
+  function removeChildrenAndAdd(parent, e) {
+    return removeChildren(parent).appendChild(e);
+  }
+
+  var contains = CodeMirror.contains = function(parent, child) {
+    if (child.nodeType == 3) // Android browser always returns false when child is a textnode
+      child = child.parentNode;
+    if (parent.contains)
+      return parent.contains(child);
+    do {
+      if (child.nodeType == 11) child = child.host;
+      if (child == parent) return true;
+    } while (child = child.parentNode);
+  };
+
+  function activeElt() { return document.activeElement; }
+  // Older versions of IE throws unspecified error when touching
+  // document.activeElement in some cases (during loading, in iframe)
+  if (ie && ie_version < 11) activeElt = function() {
+    try { return document.activeElement; }
+    catch(e) { return document.body; }
+  };
+
+  function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*"); }
+  var rmClass = CodeMirror.rmClass = function(node, cls) {
+    var current = node.className;
+    var match = classTest(cls).exec(current);
+    if (match) {
+      var after = current.slice(match.index + match[0].length);
+      node.className = current.slice(0, match.index) + (after ? match[1] + after : "");
+    }
+  };
+  var addClass = CodeMirror.addClass = function(node, cls) {
+    var current = node.className;
+    if (!classTest(cls).test(current)) node.className += (current ? " " : "") + cls;
+  };
+  function joinClasses(a, b) {
+    var as = a.split(" ");
+    for (var i = 0; i < as.length; i++)
+      if (as[i] && !classTest(as[i]).test(b)) b += " " + as[i];
+    return b;
+  }
+
+  // WINDOW-WIDE EVENTS
+
+  // These must be handled carefully, because naively registering a
+  // handler for each editor will cause the editors to never be
+  // garbage collected.
+
+  function forEachCodeMirror(f) {
+    if (!document.body.getElementsByClassName) return;
+    var byClass = document.body.getElementsByClassName("CodeMirror");
+    for (var i = 0; i < byClass.length; i++) {
+      var cm = byClass[i].CodeMirror;
+      if (cm) f(cm);
+    }
+  }
+
+  var globalsRegistered = false;
+  function ensureGlobalHandlers() {
+    if (globalsRegistered) return;
+    registerGlobalHandlers();
+    globalsRegistered = true;
+  }
+  function registerGlobalHandlers() {
+    // When the window resizes, we need to refresh active editors.
+    var resizeTimer;
+    on(window, "resize", function() {
+      if (resizeTimer == null) resizeTimer = setTimeout(function() {
+        resizeTimer = null;
+        forEachCodeMirror(onResize);
+      }, 100);
+    });
+    // When the window loses focus, we want to show the editor as blurred
+    on(window, "blur", function() {
+      forEachCodeMirror(onBlur);
+    });
+  }
+
+  // FEATURE DETECTION
+
+  // Detect drag-and-drop
+  var dragAndDrop = function() {
+    // There is *some* kind of drag-and-drop support in IE6-8, but I
+    // couldn't get it to work yet.
+    if (ie && ie_version < 9) return false;
+    var div = elt('div');
+    return "draggable" in div || "dragDrop" in div;
+  }();
+
+  var zwspSupported;
+  function zeroWidthElement(measure) {
+    if (zwspSupported == null) {
+      var test = elt("span", "\u200b");
+      removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]));
+      if (measure.firstChild.offsetHeight != 0)
+        zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8);
+    }
+    var node = zwspSupported ? elt("span", "\u200b") :
+      elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px");
+    node.setAttribute("cm-text", "");
+    return node;
+  }
+
+  // Feature-detect IE's crummy client rect reporting for bidi text
+  var badBidiRects;
+  function hasBadBidiRects(measure) {
+    if (badBidiRects != null) return badBidiRects;
+    var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"));
+    var r0 = range(txt, 0, 1).getBoundingClientRect();
+    if (!r0 || r0.left == r0.right) return false; // Safari returns null in some cases (#2780)
+    var r1 = range(txt, 1, 2).getBoundingClientRect();
+    return badBidiRects = (r1.right - r0.right < 3);
+  }
+
+  // See if "".split is the broken IE version, if so, provide an
+  // alternative way to split lines.
+  var splitLines = CodeMirror.splitLines = "\n\nb".split(/\n/).length != 3 ? function(string) {
+    var pos = 0, result = [], l = string.length;
+    while (pos <= l) {
+      var nl = string.indexOf("\n", pos);
+      if (nl == -1) nl = string.length;
+      var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl);
+      var rt = line.indexOf("\r");
+      if (rt != -1) {
+        result.push(line.slice(0, rt));
+        pos += rt + 1;
+      } else {
+        result.push(line);
+        pos = nl + 1;
+      }
+    }
+    return result;
+  } : function(string){return string.split(/\r\n?|\n/);};
+
+  var hasSelection = window.getSelection ? function(te) {
+    try { return te.selectionStart != te.selectionEnd; }
+    catch(e) { return false; }
+  } : function(te) {
+    try {var range = te.ownerDocument.selection.createRange();}
+    catch(e) {}
+    if (!range || range.parentElement() != te) return false;
+    return range.compareEndPoints("StartToEnd", range) != 0;
+  };
+
+  var hasCopyEvent = (function() {
+    var e = elt("div");
+    if ("oncopy" in e) return true;
+    e.setAttribute("oncopy", "return;");
+    return typeof e.oncopy == "function";
+  })();
+
+  var badZoomedRects = null;
+  function hasBadZoomedRects(measure) {
+    if (badZoomedRects != null) return badZoomedRects;
+    var node = removeChildrenAndAdd(measure, elt("span", "x"));
+    var normal = node.getBoundingClientRect();
+    var fromRange = range(node, 0, 1).getBoundingClientRect();
+    return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1;
+  }
+
+  // KEY NAMES
+
+  var keyNames = {3: "Enter", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
+                  19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
+                  36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
+                  46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod", 107: "=", 109: "-", 127: "Delete",
+                  173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\",
+                  221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete",
+                  63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert"};
+  CodeMirror.keyNames = keyNames;
+  (function() {
+    // Number keys
+    for (var i = 0; i < 10; i++) keyNames[i + 48] = keyNames[i + 96] = String(i);
+    // Alphabetic keys
+    for (var i = 65; i <= 90; i++) keyNames[i] = String.fromCharCode(i);
+    // Function keys
+    for (var i = 1; i <= 12; i++) keyNames[i + 111] = keyNames[i + 63235] = "F" + i;
+  })();
+
+  // BIDI HELPERS
+
+  function iterateBidiSections(order, from, to, f) {
+    if (!order) return f(from, to, "ltr");
+    var found = false;
+    for (var i = 0; i < order.length; ++i) {
+      var part = order[i];
+      if (part.from < to && part.to > from || from == to && part.to == from) {
+        f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr");
+        found = true;
+      }
+    }
+    if (!found) f(from, to, "ltr");
+  }
+
+  function bidiLeft(part) { return part.level % 2 ? part.to : part.from; }
+  function bidiRight(part) { return part.level % 2 ? part.from : part.to; }
+
+  function lineLeft(line) { var order = getOrder(line); return order ? bidiLeft(order[0]) : 0; }
+  function lineRight(line) {
+    var order = getOrder(line);
+    if (!order) return line.text.length;
+    return bidiRight(lst(order));
+  }
+
+  function lineStart(cm, lineN) {
+    var line = getLine(cm.doc, lineN);
+    var visual = visualLine(line);
+    if (visual != line) lineN = lineNo(visual);
+    var order = getOrder(visual);
+    var ch = !order ? 0 : order[0].level % 2 ? lineRight(visual) : lineLeft(visual);
+    return Pos(lineN, ch);
+  }
+  function lineEnd(cm, lineN) {
+    var merged, line = getLine(cm.doc, lineN);
+    while (merged = collapsedSpanAtEnd(line)) {
+      line = merged.find(1, true).line;
+      lineN = null;
+    }
+    var order = getOrder(line);
+    var ch = !order ? line.text.length : order[0].level % 2 ? lineLeft(line) : lineRight(line);
+    return Pos(lineN == null ? lineNo(line) : lineN, ch);
+  }
+  function lineStartSmart(cm, pos) {
+    var start = lineStart(cm, pos.line);
+    var line = getLine(cm.doc, start.line);
+    var order = getOrder(line);
+    if (!order || order[0].level == 0) {
+      var firstNonWS = Math.max(0, line.text.search(/\S/));
+      var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch;
+      return Pos(start.line, inWS ? 0 : firstNonWS);
+    }
+    return start;
+  }
+
+  function compareBidiLevel(order, a, b) {
+    var linedir = order[0].level;
+    if (a == linedir) return true;
+    if (b == linedir) return false;
+    return a < b;
+  }
+  var bidiOther;
+  function getBidiPartAt(order, pos) {
+    bidiOther = null;
+    for (var i = 0, found; i < order.length; ++i) {
+      var cur = order[i];
+      if (cur.from < pos && cur.to > pos) return i;
+      if ((cur.from == pos || cur.to == pos)) {
+        if (found == null) {
+          found = i;
+        } else if (compareBidiLevel(order, cur.level, order[found].level)) {
+          if (cur.from != cur.to) bidiOther = found;
+          return i;
+        } else {
+          if (cur.from != cur.to) bidiOther = i;
+          return found;
+        }
+      }
+    }
+    return found;
+  }
+
+  function moveInLine(line, pos, dir, byUnit) {
+    if (!byUnit) return pos + dir;
+    do pos += dir;
+    while (pos > 0 && isExtendingChar(line.text.charAt(pos)));
+    return pos;
+  }
+
+  // This is needed in order to move 'visually' through bi-directional
+  // text -- i.e., pressing left should make the cursor go left, even
+  // when in RTL text. The tricky part is the 'jumps', where RTL and
+  // LTR text touch each other. This often requires the cursor offset
+  // to move more than one unit, in order to visually move one unit.
+  function moveVisually(line, start, dir, byUnit) {
+    var bidi = getOrder(line);
+    if (!bidi) return moveLogically(line, start, dir, byUnit);
+    var pos = getBidiPartAt(bidi, start), part = bidi[pos];
+    var target = moveInLine(line, start, part.level % 2 ? -dir : dir, byUnit);
+
+    for (;;) {
+      if (target > part.from && target < part.to) return target;
+      if (target == part.from || target == part.to) {
+        if (getBidiPartAt(bidi, target) == pos) return target;
+        part = bidi[pos += dir];
+        return (dir > 0) == part.level % 2 ? part.to : part.from;
+      } else {
+        part = bidi[pos += dir];
+        if (!part) return null;
+        if ((dir > 0) == part.level % 2)
+          target = moveInLine(line, part.to, -1, byUnit);
+        else
+          target = moveInLine(line, part.from, 1, byUnit);
+      }
+    }
+  }
+
+  function moveLogically(line, start, dir, byUnit) {
+    var target = start + dir;
+    if (byUnit) while (target > 0 && isExtendingChar(line.text.charAt(target))) target += dir;
+    return target < 0 || target > line.text.length ? null : target;
+  }
+
+  // Bidirectional ordering algorithm
+  // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
+  // that this (partially) implements.
+
+  // One-char codes used for character types:
+  // L (L):   Left-to-Right
+  // R (R):   Right-to-Left
+  // r (AL):  Right-to-Left Arabic
+  // 1 (EN):  European Number
+  // + (ES):  European Number Separator
+  // % (ET):  European Number Terminator
+  // n (AN):  Arabic Number
+  // , (CS):  Common Number Separator
+  // m (NSM): Non-Spacing Mark
+  // b (BN):  Boundary Neutral
+  // s (B):   Paragraph Separator
+  // t (S):   Segment Separator
+  // w (WS):  Whitespace
+  // N (ON):  Other Neutrals
+
+  // Returns null if characters are ordered as they appear
+  // (left-to-right), or an array of sections ({from, to, level}
+  // objects) in the order in which they occur visually.
+  var bidiOrdering = (function() {
+    // Character types for codepoints 0 to 0xff
+    var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN";
+    // Character types for codepoints 0x600 to 0x6ff
+    var arabicTypes = "rrrrrrrrrrrr,rNNmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmrrrrrrrnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmNmmmm";
+    function charType(code) {
+      if (code <= 0xf7) return lowTypes.charAt(code);
+      else if (0x590 <= code && code <= 0x5f4) return "R";
+      else if (0x600 <= code && code <= 0x6ed) return arabicTypes.charAt(code - 0x600);
+      else if (0x6ee <= code && code <= 0x8ac) return "r";
+      else if (0x2000 <= code && code <= 0x200b) return "w";
+      else if (code == 0x200c) return "b";
+      else return "L";
+    }
+
+    var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;
+    var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/;
+    // Browsers seem to always treat the boundaries of block elements as being L.
+    var outerType = "L";
+
+    function BidiSpan(level, from, to) {
+      this.level = level;
+      this.from = from; this.to = to;
+    }
+
+    return function(str) {
+      if (!bidiRE.test(str)) return false;
+      var len = str.length, types = [];
+      for (var i = 0, type; i < len; ++i)
+        types.push(type = charType(str.charCodeAt(i)));
+
+      // W1. Examine each non-spacing mark (NSM) in the level run, and
+      // change the type of the NSM to the type of the previous
+      // character. If the NSM is at the start of the level run, it will
+      // get the type of sor.
+      for (var i = 0, prev = outerType; i < len; ++i) {
+        var type = types[i];
+        if (type == "m") types[i] = prev;
+        else prev = type;
+      }
+
+      // W2. Search backwards from each instance of a European number
+      // until the first strong type (R, L, AL, or sor) is found. If an
+      // AL is found, change the type of the European number to Arabic
+      // number.
+      // W3. Change all ALs to R.
+      for (var i = 0, cur = outerType; i < len; ++i) {
+        var type = types[i];
+        if (type == "1" && cur == "r") types[i] = "n";
+        else if (isStrong.test(type)) { cur = type; if (type == "r") types[i] = "R"; }
+      }
+
+      // W4. A single European separator between two European numbers
+      // changes to a European number. A single common separator between
+      // two numbers of the same type changes to that type.
+      for (var i = 1, prev = types[0]; i < len - 1; ++i) {
+        var type = types[i];
+        if (type == "+" && prev == "1" && types[i+1] == "1") types[i] = "1";
+        else if (type == "," && prev == types[i+1] &&
+                 (prev == "1" || prev == "n")) types[i] = prev;
+        prev = type;
+      }
+
+      // W5. A sequence of European terminators adjacent to European
+      // numbers changes to all European numbers.
+      // W6. Otherwise, separators and terminators change to Other
+      // Neutral.
+      for (var i = 0; i < len; ++i) {
+        var type = types[i];
+        if (type == ",") types[i] = "N";
+        else if (type == "%") {
+          for (var end = i + 1; end < len && types[end] == "%"; ++end) {}
+          var replace = (i && types[i-1] == "!") || (end < len && types[end] == "1") ? "1" : "N";
+          for (var j = i; j < end; ++j) types[j] = replace;
+          i = end - 1;
+        }
+      }
+
+      // W7. Search backwards from each instance of a European number
+      // until the first strong type (R, L, or sor) is found. If an L is
+      // found, then change the type of the European number to L.
+      for (var i = 0, cur = outerType; i < len; ++i) {
+        var type = types[i];
+        if (cur == "L" && type == "1") types[i] = "L";
+        else if (isStrong.test(type)) cur = type;
+      }
+
+      // N1. A sequence of neutrals takes the direction of the
+      // surrounding strong text if the text on both sides has the same
+      // direction. European and Arabic numbers act as if they were R in
+      // terms of their influence on neutrals. Start-of-level-run (sor)
+      // and end-of-level-run (eor) are used at level run boundaries.
+      // N2. Any remaining neutrals take the embedding direction.
+      for (var i = 0; i < len; ++i) {
+        if (isNeutral.test(types[i])) {
+          for (var end = i + 1; end < len && isNeutral.test(types[end]); ++end) {}
+          var before = (i ? types[i-1] : outerType) == "L";
+          var after = (end < len ? types[end] : outerType) == "L";
+          var replace = before || after ? "L" : "R";
+          for (var j = i; j < end; ++j) types[j] = replace;
+          i = end - 1;
+        }
+      }
+
+      // Here we depart from the documented algorithm, in order to avoid
+      // building up an actual levels array. Since there are only three
+      // levels (0, 1, 2) in an implementation that doesn't take
+      // explicit embedding into account, we can build up the order on
+      // the fly, without following the level-based algorithm.
+      var order = [], m;
+      for (var i = 0; i < len;) {
+        if (countsAsLeft.test(types[i])) {
+          var start = i;
+          for (++i; i < len && countsAsLeft.test(types[i]); ++i) {}
+          order.push(new BidiSpan(0, start, i));
+        } else {
+          var pos = i, at = order.length;
+          for (++i; i < len && types[i] != "L"; ++i) {}
+          for (var j = pos; j < i;) {
+            if (countsAsNum.test(types[j])) {
+              if (pos < j) order.splice(at, 0, new BidiSpan(1, pos, j));
+              var nstart = j;
+              for (++j; j < i && countsAsNum.test(types[j]); ++j) {}
+              order.splice(at, 0, new BidiSpan(2, nstart, j));
+              pos = j;
+            } else ++j;
+          }
+          if (pos < i) order.splice(at, 0, new BidiSpan(1, pos, i));
+        }
+      }
+      if (order[0].level == 1 && (m = str.match(/^\s+/))) {
+        order[0].from = m[0].length;
+        order.unshift(new BidiSpan(0, 0, m[0].length));
+      }
+      if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
+        lst(order).to -= m[0].length;
+        order.push(new BidiSpan(0, len - m[0].length, len));
+      }
+      if (order[0].level == 2)
+        order.unshift(new BidiSpan(1, order[0].to, order[0].to));
+      if (order[0].level != lst(order).level)
+        order.push(new BidiSpan(order[0].level, len, len));
+
+      return order;
+    };
+  })();
+
+  // THE END
+
+  CodeMirror.version = "5.4.1";
+
+  return CodeMirror;
+});
diff --git a/src/main/resources/codemirror/mode/cobol/cobol.js b/src/main/resources/codemirror/mode/cobol/cobol.js
new file mode 100755
index 0000000..897022b
--- /dev/null
+++ b/src/main/resources/codemirror/mode/cobol/cobol.js
@@ -0,0 +1,255 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+/**
+ * Author: Gautam Mehta
+ * Branched from CodeMirror's Scheme mode
+ */
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("cobol", function () {
+  var BUILTIN = "builtin", COMMENT = "comment", STRING = "string",
+      ATOM = "atom", NUMBER = "number", KEYWORD = "keyword", MODTAG = "header",
+      COBOLLINENUM = "def", PERIOD = "link";
+  function makeKeywords(str) {
+    var obj = {}, words = str.split(" ");
+    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+    return obj;
+  }
+  var atoms = makeKeywords("TRUE FALSE ZEROES ZEROS ZERO SPACES SPACE LOW-VALUE LOW-VALUES ");
+  var keywords = makeKeywords(
+      "ACCEPT ACCESS ACQUIRE ADD ADDRESS " +
+      "ADVANCING AFTER ALIAS ALL ALPHABET " +
+      "ALPHABETIC ALPHABETIC-LOWER ALPHABETIC-UPPER ALPHANUMERIC ALPHANUMERIC-EDITED " +
+      "ALSO ALTER ALTERNATE AND ANY " +
+      "ARE AREA AREAS ARITHMETIC ASCENDING " +
+      "ASSIGN AT ATTRIBUTE AUTHOR AUTO " +
+      "AUTO-SKIP AUTOMATIC B-AND B-EXOR B-LESS " +
+      "B-NOT B-OR BACKGROUND-COLOR BACKGROUND-COLOUR BEEP " +
+      "BEFORE BELL BINARY BIT BITS " +
+      "BLANK BLINK BLOCK BOOLEAN BOTTOM " +
+      "BY CALL CANCEL CD CF " +
+      "CH CHARACTER CHARACTERS CLASS CLOCK-UNITS " +
+      "CLOSE COBOL CODE CODE-SET COL " +
+      "COLLATING COLUMN COMMA COMMIT COMMITMENT " +
+      "COMMON COMMUNICATION COMP COMP-0 COMP-1 " +
+      "COMP-2 COMP-3 COMP-4 COMP-5 COMP-6 " +
+      "COMP-7 COMP-8 COMP-9 COMPUTATIONAL COMPUTATIONAL-0 " +
+      "COMPUTATIONAL-1 COMPUTATIONAL-2 COMPUTATIONAL-3 COMPUTATIONAL-4 COMPUTATIONAL-5 " +
+      "COMPUTATIONAL-6 COMPUTATIONAL-7 COMPUTATIONAL-8 COMPUTATIONAL-9 COMPUTE " +
+      "CONFIGURATION CONNECT CONSOLE CONTAINED CONTAINS " +
+      "CONTENT CONTINUE CONTROL CONTROL-AREA CONTROLS " +
+      "CONVERTING COPY CORR CORRESPONDING COUNT " +
+      "CRT CRT-UNDER CURRENCY CURRENT CURSOR " +
+      "DATA DATE DATE-COMPILED DATE-WRITTEN DAY " +
+      "DAY-OF-WEEK DB DB-ACCESS-CONTROL-KEY DB-DATA-NAME DB-EXCEPTION " +
+      "DB-FORMAT-NAME DB-RECORD-NAME DB-SET-NAME DB-STATUS DBCS " +
+      "DBCS-EDITED DE DEBUG-CONTENTS DEBUG-ITEM DEBUG-LINE " +
+      "DEBUG-NAME DEBUG-SUB-1 DEBUG-SUB-2 DEBUG-SUB-3 DEBUGGING " +
+      "DECIMAL-POINT DECLARATIVES DEFAULT DELETE DELIMITED " +
+      "DELIMITER DEPENDING DESCENDING DESCRIBED DESTINATION " +
+      "DETAIL DISABLE DISCONNECT DISPLAY DISPLAY-1 " +
+      "DISPLAY-2 DISPLAY-3 DISPLAY-4 DISPLAY-5 DISPLAY-6 " +
+      "DISPLAY-7 DISPLAY-8 DISPLAY-9 DIVIDE DIVISION " +
+      "DOWN DROP DUPLICATE DUPLICATES DYNAMIC " +
+      "EBCDIC EGI EJECT ELSE EMI " +
+      "EMPTY EMPTY-CHECK ENABLE END END. END-ACCEPT END-ACCEPT. " +
+      "END-ADD END-CALL END-COMPUTE END-DELETE END-DISPLAY " +
+      "END-DIVIDE END-EVALUATE END-IF END-INVOKE END-MULTIPLY " +
+      "END-OF-PAGE END-PERFORM END-READ END-RECEIVE END-RETURN " +
+      "END-REWRITE END-SEARCH END-START END-STRING END-SUBTRACT " +
+      "END-UNSTRING END-WRITE END-XML ENTER ENTRY " +
+      "ENVIRONMENT EOP EQUAL EQUALS ERASE " +
+      "ERROR ESI EVALUATE EVERY EXCEEDS " +
+      "EXCEPTION EXCLUSIVE EXIT EXTEND EXTERNAL " +
+      "EXTERNALLY-DESCRIBED-KEY FD FETCH FILE FILE-CONTROL " +
+      "FILE-STREAM FILES FILLER FINAL FIND " +
+      "FINISH FIRST FOOTING FOR FOREGROUND-COLOR " +
+      "FOREGROUND-COLOUR FORMAT FREE FROM FULL " +
+      "FUNCTION GENERATE GET GIVING GLOBAL " +
+      "GO GOBACK GREATER GROUP HEADING " +
+      "HIGH-VALUE HIGH-VALUES HIGHLIGHT I-O I-O-CONTROL " +
+      "ID IDENTIFICATION IF IN INDEX " +
+      "INDEX-1 INDEX-2 INDEX-3 INDEX-4 INDEX-5 " +
+      "INDEX-6 INDEX-7 INDEX-8 INDEX-9 INDEXED " +
+      "INDIC INDICATE INDICATOR INDICATORS INITIAL " +
+      "INITIALIZE INITIATE INPUT INPUT-OUTPUT INSPECT " +
+      "INSTALLATION INTO INVALID INVOKE IS " +
+      "JUST JUSTIFIED KANJI KEEP KEY " +
+      "LABEL LAST LD LEADING LEFT " +
+      "LEFT-JUSTIFY LENGTH LENGTH-CHECK LESS LIBRARY " +
+      "LIKE LIMIT LIMITS LINAGE LINAGE-COUNTER " +
+      "LINE LINE-COUNTER LINES LINKAGE LOCAL-STORAGE " +
+      "LOCALE LOCALLY LOCK " +
+      "MEMBER MEMORY MERGE MESSAGE METACLASS " +
+      "MODE MODIFIED MODIFY MODULES MOVE " +
+      "MULTIPLE MULTIPLY NATIONAL NATIVE NEGATIVE " +
+      "NEXT NO NO-ECHO NONE NOT " +
+      "NULL NULL-KEY-MAP NULL-MAP NULLS NUMBER " +
+      "NUMERIC NUMERIC-EDITED OBJECT OBJECT-COMPUTER OCCURS " +
+      "OF OFF OMITTED ON ONLY " +
+      "OPEN OPTIONAL OR ORDER ORGANIZATION " +
+      "OTHER OUTPUT OVERFLOW OWNER PACKED-DECIMAL " +
+      "PADDING PAGE PAGE-COUNTER PARSE PERFORM " +
+      "PF PH PIC PICTURE PLUS " +
+      "POINTER POSITION POSITIVE PREFIX PRESENT " +
+      "PRINTING PRIOR PROCEDURE PROCEDURE-POINTER PROCEDURES " +
+      "PROCEED PROCESS PROCESSING PROGRAM PROGRAM-ID " +
+      "PROMPT PROTECTED PURGE QUEUE QUOTE " +
+      "QUOTES RANDOM RD READ READY " +
+      "REALM RECEIVE RECONNECT RECORD RECORD-NAME " +
+      "RECORDS RECURSIVE REDEFINES REEL REFERENCE " +
+      "REFERENCE-MONITOR REFERENCES RELATION RELATIVE RELEASE " +
+      "REMAINDER REMOVAL RENAMES REPEATED REPLACE " +
+      "REPLACING REPORT REPORTING REPORTS REPOSITORY " +
+      "REQUIRED RERUN RESERVE RESET RETAINING " +
+      "RETRIEVAL RETURN RETURN-CODE RETURNING REVERSE-VIDEO " +
+      "REVERSED REWIND REWRITE RF RH " +
+      "RIGHT RIGHT-JUSTIFY ROLLBACK ROLLING ROUNDED " +
+      "RUN SAME SCREEN SD SEARCH " +
+      "SECTION SECURE SECURITY SEGMENT SEGMENT-LIMIT " +
+      "SELECT SEND SENTENCE SEPARATE SEQUENCE " +
+      "SEQUENTIAL SET SHARED SIGN SIZE " +
+      "SKIP1 SKIP2 SKIP3 SORT SORT-MERGE " +
+      "SORT-RETURN SOURCE SOURCE-COMPUTER SPACE-FILL " +
+      "SPECIAL-NAMES STANDARD STANDARD-1 STANDARD-2 " +
+      "START STARTING STATUS STOP STORE " +
+      "STRING SUB-QUEUE-1 SUB-QUEUE-2 SUB-QUEUE-3 SUB-SCHEMA " +
+      "SUBFILE SUBSTITUTE SUBTRACT SUM SUPPRESS " +
+      "SYMBOLIC SYNC SYNCHRONIZED SYSIN SYSOUT " +
+      "TABLE TALLYING TAPE TENANT TERMINAL " +
+      "TERMINATE TEST TEXT THAN THEN " +
+      "THROUGH THRU TIME TIMES TITLE " +
+      "TO TOP TRAILING TRAILING-SIGN TRANSACTION " +
+      "TYPE TYPEDEF UNDERLINE UNEQUAL UNIT " +
+      "UNSTRING UNTIL UP UPDATE UPON " +
+      "USAGE USAGE-MODE USE USING VALID " +
+      "VALIDATE VALUE VALUES VARYING VLR " +
+      "WAIT WHEN WHEN-COMPILED WITH WITHIN " +
+      "WORDS WORKING-STORAGE WRITE XML XML-CODE " +
+      "XML-EVENT XML-NTEXT XML-TEXT ZERO ZERO-FILL " );
+
+  var builtins = makeKeywords("- * ** / + < <= = > >= ");
+  var tests = {
+    digit: /\d/,
+    digit_or_colon: /[\d:]/,
+    hex: /[0-9a-f]/i,
+    sign: /[+-]/,
+    exponent: /e/i,
+    keyword_char: /[^\s\(\[\;\)\]]/,
+    symbol: /[\w*+\-]/
+  };
+  function isNumber(ch, stream){
+    // hex
+    if ( ch === '0' && stream.eat(/x/i) ) {
+      stream.eatWhile(tests.hex);
+      return true;
+    }
+    // leading sign
+    if ( ( ch == '+' || ch == '-' ) && ( tests.digit.test(stream.peek()) ) ) {
+      stream.eat(tests.sign);
+      ch = stream.next();
+    }
+    if ( tests.digit.test(ch) ) {
+      stream.eat(ch);
+      stream.eatWhile(tests.digit);
+      if ( '.' == stream.peek()) {
+        stream.eat('.');
+        stream.eatWhile(tests.digit);
+      }
+      if ( stream.eat(tests.exponent) ) {
+        stream.eat(tests.sign);
+        stream.eatWhile(tests.digit);
+      }
+      return true;
+    }
+    return false;
+  }
+  return {
+    startState: function () {
+      return {
+        indentStack: null,
+        indentation: 0,
+        mode: false
+      };
+    },
+    token: function (stream, state) {
+      if (state.indentStack == null && stream.sol()) {
+        // update indentation, but only if indentStack is empty
+        state.indentation = 6 ; //stream.indentation();
+      }
+      // skip spaces
+      if (stream.eatSpace()) {
+        return null;
+      }
+      var returnType = null;
+      switch(state.mode){
+      case "string": // multi-line string parsing mode
+        var next = false;
+        while ((next = stream.next()) != null) {
+          if (next == "\"" || next == "\'") {
+            state.mode = false;
+            break;
+          }
+        }
+        returnType = STRING; // continue on in string mode
+        break;
+      default: // default parsing mode
+        var ch = stream.next();
+        var col = stream.column();
+        if (col >= 0 && col <= 5) {
+          returnType = COBOLLINENUM;
+        } else if (col >= 72 && col <= 79) {
+          stream.skipToEnd();
+          returnType = MODTAG;
+        } else if (ch == "*" && col == 6) { // comment
+          stream.skipToEnd(); // rest of the line is a comment
+          returnType = COMMENT;
+        } else if (ch == "\"" || ch == "\'") {
+          state.mode = "string";
+          returnType = STRING;
+        } else if (ch == "'" && !( tests.digit_or_colon.test(stream.peek()) )) {
+          returnType = ATOM;
+        } else if (ch == ".") {
+          returnType = PERIOD;
+        } else if (isNumber(ch,stream)){
+          returnType = NUMBER;
+        } else {
+          if (stream.current().match(tests.symbol)) {
+            while (col < 71) {
+              if (stream.eat(tests.symbol) === undefined) {
+                break;
+              } else {
+                col++;
+              }
+            }
+          }
+          if (keywords && keywords.propertyIsEnumerable(stream.current().toUpperCase())) {
+            returnType = KEYWORD;
+          } else if (builtins && builtins.propertyIsEnumerable(stream.current().toUpperCase())) {
+            returnType = BUILTIN;
+          } else if (atoms && atoms.propertyIsEnumerable(stream.current().toUpperCase())) {
+            returnType = ATOM;
+          } else returnType = null;
+        }
+      }
+      return returnType;
+    },
+    indent: function (state) {
+      if (state.indentStack == null) return state.indentation;
+      return state.indentStack.indent;
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/x-cobol", "cobol");
+
+});
diff --git a/src/main/resources/codemirror/mode/cobol/index.html b/src/main/resources/codemirror/mode/cobol/index.html
new file mode 100755
index 0000000..4352419
--- /dev/null
+++ b/src/main/resources/codemirror/mode/cobol/index.html
@@ -0,0 +1,210 @@
+<!doctype html>
+
+<title>CodeMirror: COBOL mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<link rel="stylesheet" href="../../theme/neat.css">
+<link rel="stylesheet" href="../../theme/elegant.css">
+<link rel="stylesheet" href="../../theme/erlang-dark.css">
+<link rel="stylesheet" href="../../theme/night.css">
+<link rel="stylesheet" href="../../theme/monokai.css">
+<link rel="stylesheet" href="../../theme/cobalt.css">
+<link rel="stylesheet" href="../../theme/eclipse.css">
+<link rel="stylesheet" href="../../theme/rubyblue.css">
+<link rel="stylesheet" href="../../theme/lesser-dark.css">
+<link rel="stylesheet" href="../../theme/xq-dark.css">
+<link rel="stylesheet" href="../../theme/xq-light.css">
+<link rel="stylesheet" href="../../theme/ambiance.css">
+<link rel="stylesheet" href="../../theme/blackboard.css">
+<link rel="stylesheet" href="../../theme/vibrant-ink.css">
+<link rel="stylesheet" href="../../theme/solarized.css">
+<link rel="stylesheet" href="../../theme/twilight.css">
+<link rel="stylesheet" href="../../theme/midnight.css">
+<link rel="stylesheet" href="../../addon/dialog/dialog.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="../../addon/edit/matchbrackets.js"></script>
+<script src="cobol.js"></script>
+<script src="../../addon/selection/active-line.js"></script>
+<script src="../../addon/search/search.js"></script>
+<script src="../../addon/dialog/dialog.js"></script>
+<script src="../../addon/search/searchcursor.js"></script>
+<style>
+        .CodeMirror {
+          border: 1px solid #eee;
+          font-size : 20px;
+          height : auto !important;
+        }
+        .CodeMirror-activeline-background {background: #555555 !important;}
+    </style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">COBOL</a>
+  </ul>
+</div>
+
+<article>
+<h2>COBOL mode</h2>
+
+    <p> Select Theme <select onchange="selectTheme()" id="selectTheme">
+        <option>default</option>
+        <option>ambiance</option>
+        <option>blackboard</option>
+        <option>cobalt</option>
+        <option>eclipse</option>
+        <option>elegant</option>
+        <option>erlang-dark</option>
+        <option>lesser-dark</option>
+        <option>midnight</option>
+        <option>monokai</option>
+        <option>neat</option>
+        <option>night</option>
+        <option>rubyblue</option>
+        <option>solarized dark</option>
+        <option>solarized light</option>
+        <option selected>twilight</option>
+        <option>vibrant-ink</option>
+        <option>xq-dark</option>
+        <option>xq-light</option>
+    </select>    Select Font Size <select onchange="selectFontsize()" id="selectFontSize">
+          <option value="13px">13px</option>
+          <option value="14px">14px</option>
+          <option value="16px">16px</option>
+          <option value="18px">18px</option>
+          <option value="20px" selected="selected">20px</option>
+          <option value="24px">24px</option>
+          <option value="26px">26px</option>
+          <option value="28px">28px</option>
+          <option value="30px">30px</option>
+          <option value="32px">32px</option>
+          <option value="34px">34px</option>
+          <option value="36px">36px</option>
+        </select>
+<label for="checkBoxReadOnly">Read-only</label>
+<input type="checkbox" id="checkBoxReadOnly" onchange="selectReadOnly()">
+<label for="id_tabToIndentSpace">Insert Spaces on Tab</label>
+<input type="checkbox" id="id_tabToIndentSpace" onchange="tabToIndentSpace()">
+</p>
+<textarea id="code" name="code">
+---------1---------2---------3---------4---------5---------6---------7---------8
+12345678911234567892123456789312345678941234567895123456789612345678971234567898
+000010 IDENTIFICATION DIVISION.                                        MODTGHERE
+000020 PROGRAM-ID.       SAMPLE.
+000030 AUTHOR.           TEST SAM. 
+000040 DATE-WRITTEN.     5 February 2013
+000041
+000042* A sample program just to show the form.
+000043* The program copies its input to the output,
+000044* and counts the number of records.
+000045* At the end this number is printed.
+000046
+000050 ENVIRONMENT DIVISION.
+000060 INPUT-OUTPUT SECTION.
+000070 FILE-CONTROL.
+000080     SELECT STUDENT-FILE     ASSIGN TO SYSIN
+000090         ORGANIZATION IS LINE SEQUENTIAL.
+000100     SELECT PRINT-FILE       ASSIGN TO SYSOUT
+000110         ORGANIZATION IS LINE SEQUENTIAL.
+000120
+000130 DATA DIVISION.
+000140 FILE SECTION.
+000150 FD  STUDENT-FILE
+000160     RECORD CONTAINS 43 CHARACTERS
+000170     DATA RECORD IS STUDENT-IN.
+000180 01  STUDENT-IN              PIC X(43).
+000190
+000200 FD  PRINT-FILE
+000210     RECORD CONTAINS 80 CHARACTERS
+000220     DATA RECORD IS PRINT-LINE.
+000230 01  PRINT-LINE              PIC X(80).
+000240
+000250 WORKING-STORAGE SECTION.
+000260 01  DATA-REMAINS-SWITCH     PIC X(2)      VALUE SPACES.
+000261 01  RECORDS-WRITTEN         PIC 99.
+000270
+000280 01  DETAIL-LINE.
+000290     05  FILLER              PIC X(7)      VALUE SPACES.
+000300     05  RECORD-IMAGE        PIC X(43).
+000310     05  FILLER              PIC X(30)     VALUE SPACES.
+000311 
+000312 01  SUMMARY-LINE.
+000313     05  FILLER              PIC X(7)      VALUE SPACES.
+000314     05  TOTAL-READ          PIC 99.
+000315     05  FILLER              PIC X         VALUE SPACE.
+000316     05  FILLER              PIC X(17)     
+000317                 VALUE  'Records were read'.
+000318     05  FILLER              PIC X(53)     VALUE SPACES.
+000319
+000320 PROCEDURE DIVISION.
+000321
+000330 PREPARE-SENIOR-REPORT.
+000340     OPEN INPUT  STUDENT-FILE
+000350          OUTPUT PRINT-FILE.
+000351     MOVE ZERO TO RECORDS-WRITTEN.
+000360     READ STUDENT-FILE
+000370         AT END MOVE 'NO' TO DATA-REMAINS-SWITCH
+000380     END-READ.
+000390     PERFORM PROCESS-RECORDS
+000410         UNTIL DATA-REMAINS-SWITCH = 'NO'.
+000411     PERFORM PRINT-SUMMARY.
+000420     CLOSE STUDENT-FILE
+000430           PRINT-FILE.
+000440     STOP RUN.
+000450
+000460 PROCESS-RECORDS.
+000470     MOVE STUDENT-IN TO RECORD-IMAGE.
+000480     MOVE DETAIL-LINE TO PRINT-LINE.
+000490     WRITE PRINT-LINE.
+000500     ADD 1 TO RECORDS-WRITTEN.
+000510     READ STUDENT-FILE
+000520         AT END MOVE 'NO' TO DATA-REMAINS-SWITCH
+000530     END-READ. 
+000540
+000550 PRINT-SUMMARY.
+000560     MOVE RECORDS-WRITTEN TO TOTAL-READ.
+000570     MOVE SUMMARY-LINE TO PRINT-LINE.
+000571     WRITE PRINT-LINE. 
+000572
+000580
+</textarea>
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        lineNumbers: true,
+        matchBrackets: true,
+        mode: "text/x-cobol",
+        theme : "twilight",
+        styleActiveLine: true,
+        showCursorWhenSelecting : true,  
+      });
+      function selectTheme() {
+        var themeInput = document.getElementById("selectTheme");
+        var theme = themeInput.options[themeInput.selectedIndex].innerHTML;
+        editor.setOption("theme", theme);
+      }
+      function selectFontsize() {
+        var fontSizeInput = document.getElementById("selectFontSize");
+        var fontSize = fontSizeInput.options[fontSizeInput.selectedIndex].innerHTML;
+        editor.getWrapperElement().style.fontSize = fontSize;
+        editor.refresh();
+      }
+      function selectReadOnly() {
+        editor.setOption("readOnly", document.getElementById("checkBoxReadOnly").checked);
+      }
+      function tabToIndentSpace() {
+        if (document.getElementById("id_tabToIndentSpace").checked) {
+            editor.setOption("extraKeys", {Tab: function(cm) { cm.replaceSelection("    ", "end"); }});
+        } else {
+            editor.setOption("extraKeys", {Tab: function(cm) { cm.replaceSelection("    ", "end"); }});
+        }
+      }
+    </script>
+  </article>
diff --git a/src/main/resources/codemirror/mode/commonlisp/commonlisp.js b/src/main/resources/codemirror/mode/commonlisp/commonlisp.js
new file mode 100755
index 0000000..fb1f99c
--- /dev/null
+++ b/src/main/resources/codemirror/mode/commonlisp/commonlisp.js
@@ -0,0 +1,123 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("commonlisp", function (config) {
+  var specialForm = /^(block|let*|return-from|catch|load-time-value|setq|eval-when|locally|symbol-macrolet|flet|macrolet|tagbody|function|multiple-value-call|the|go|multiple-value-prog1|throw|if|progn|unwind-protect|labels|progv|let|quote)$/;
+  var assumeBody = /^with|^def|^do|^prog|case$|^cond$|bind$|when$|unless$/;
+  var numLiteral = /^(?:[+\-]?(?:\d+|\d*\.\d+)(?:[efd][+\-]?\d+)?|[+\-]?\d+(?:\/[+\-]?\d+)?|#b[+\-]?[01]+|#o[+\-]?[0-7]+|#x[+\-]?[\da-f]+)/;
+  var symbol = /[^\s'`,@()\[\]";]/;
+  var type;
+
+  function readSym(stream) {
+    var ch;
+    while (ch = stream.next()) {
+      if (ch == "\\") stream.next();
+      else if (!symbol.test(ch)) { stream.backUp(1); break; }
+    }
+    return stream.current();
+  }
+
+  function base(stream, state) {
+    if (stream.eatSpace()) {type = "ws"; return null;}
+    if (stream.match(numLiteral)) return "number";
+    var ch = stream.next();
+    if (ch == "\\") ch = stream.next();
+
+    if (ch == '"') return (state.tokenize = inString)(stream, state);
+    else if (ch == "(") { type = "open"; return "bracket"; }
+    else if (ch == ")" || ch == "]") { type = "close"; return "bracket"; }
+    else if (ch == ";") { stream.skipToEnd(); type = "ws"; return "comment"; }
+    else if (/['`,@]/.test(ch)) return null;
+    else if (ch == "|") {
+      if (stream.skipTo("|")) { stream.next(); return "symbol"; }
+      else { stream.skipToEnd(); return "error"; }
+    } else if (ch == "#") {
+      var ch = stream.next();
+      if (ch == "[") { type = "open"; return "bracket"; }
+      else if (/[+\-=\.']/.test(ch)) return null;
+      else if (/\d/.test(ch) && stream.match(/^\d*#/)) return null;
+      else if (ch == "|") return (state.tokenize = inComment)(stream, state);
+      else if (ch == ":") { readSym(stream); return "meta"; }
+      else return "error";
+    } else {
+      var name = readSym(stream);
+      if (name == ".") return null;
+      type = "symbol";
+      if (name == "nil" || name == "t" || name.charAt(0) == ":") return "atom";
+      if (state.lastType == "open" && (specialForm.test(name) || assumeBody.test(name))) return "keyword";
+      if (name.charAt(0) == "&") return "variable-2";
+      return "variable";
+    }
+  }
+
+  function inString(stream, state) {
+    var escaped = false, next;
+    while (next = stream.next()) {
+      if (next == '"' && !escaped) { state.tokenize = base; break; }
+      escaped = !escaped && next == "\\";
+    }
+    return "string";
+  }
+
+  function inComment(stream, state) {
+    var next, last;
+    while (next = stream.next()) {
+      if (next == "#" && last == "|") { state.tokenize = base; break; }
+      last = next;
+    }
+    type = "ws";
+    return "comment";
+  }
+
+  return {
+    startState: function () {
+      return {ctx: {prev: null, start: 0, indentTo: 0}, lastType: null, tokenize: base};
+    },
+
+    token: function (stream, state) {
+      if (stream.sol() && typeof state.ctx.indentTo != "number")
+        state.ctx.indentTo = state.ctx.start + 1;
+
+      type = null;
+      var style = state.tokenize(stream, state);
+      if (type != "ws") {
+        if (state.ctx.indentTo == null) {
+          if (type == "symbol" && assumeBody.test(stream.current()))
+            state.ctx.indentTo = state.ctx.start + config.indentUnit;
+          else
+            state.ctx.indentTo = "next";
+        } else if (state.ctx.indentTo == "next") {
+          state.ctx.indentTo = stream.column();
+        }
+        state.lastType = type;
+      }
+      if (type == "open") state.ctx = {prev: state.ctx, start: stream.column(), indentTo: null};
+      else if (type == "close") state.ctx = state.ctx.prev || state.ctx;
+      return style;
+    },
+
+    indent: function (state, _textAfter) {
+      var i = state.ctx.indentTo;
+      return typeof i == "number" ? i : state.ctx.start + 1;
+    },
+
+    closeBrackets: {pairs: "()[]{}\"\""},
+    lineComment: ";;",
+    blockCommentStart: "#|",
+    blockCommentEnd: "|#"
+  };
+});
+
+CodeMirror.defineMIME("text/x-common-lisp", "commonlisp");
+
+});
diff --git a/src/main/resources/codemirror/mode/commonlisp/index.html b/src/main/resources/codemirror/mode/commonlisp/index.html
new file mode 100755
index 0000000..f2bf452
--- /dev/null
+++ b/src/main/resources/codemirror/mode/commonlisp/index.html
@@ -0,0 +1,177 @@
+<!doctype html>
+
+<title>CodeMirror: Common Lisp mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="commonlisp.js"></script>
+<style>.CodeMirror {background: #f8f8f8;}</style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Common Lisp</a>
+  </ul>
+</div>
+
+<article>
+<h2>Common Lisp mode</h2>
+<form><textarea id="code" name="code">(in-package :cl-postgres)
+
+;; These are used to synthesize reader and writer names for integer
+;; reading/writing functions when the amount of bytes and the
+;; signedness is known. Both the macro that creates the functions and
+;; some macros that use them create names this way.
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defun integer-reader-name (bytes signed)
+    (intern (with-standard-io-syntax
+              (format nil "~a~a~a~a" '#:read- (if signed "" '#:u) '#:int bytes))))
+  (defun integer-writer-name (bytes signed)
+    (intern (with-standard-io-syntax
+              (format nil "~a~a~a~a" '#:write- (if signed "" '#:u) '#:int bytes)))))
+
+(defmacro integer-reader (bytes)
+  "Create a function to read integers from a binary stream."
+  (let ((bits (* bytes 8)))
+    (labels ((return-form (signed)
+               (if signed
+                   `(if (logbitp ,(1- bits) result)
+                        (dpb result (byte ,(1- bits) 0) -1)
+                        result)
+                   `result))
+             (generate-reader (signed)
+               `(defun ,(integer-reader-name bytes signed) (socket)
+                  (declare (type stream socket)
+                           #.*optimize*)
+                  ,(if (= bytes 1)
+                       `(let ((result (the (unsigned-byte 8) (read-byte socket))))
+                          (declare (type (unsigned-byte 8) result))
+                          ,(return-form signed))
+                       `(let ((result 0))
+                          (declare (type (unsigned-byte ,bits) result))
+                          ,@(loop :for byte :from (1- bytes) :downto 0
+                                   :collect `(setf (ldb (byte 8 ,(* 8 byte)) result)
+                                                   (the (unsigned-byte 8) (read-byte socket))))
+                          ,(return-form signed))))))
+      `(progn
+;; This causes weird errors on SBCL in some circumstances. Disabled for now.
+;;         (declaim (inline ,(integer-reader-name bytes t)
+;;                          ,(integer-reader-name bytes nil)))
+         (declaim (ftype (function (t) (signed-byte ,bits))
+                         ,(integer-reader-name bytes t)))
+         ,(generate-reader t)
+         (declaim (ftype (function (t) (unsigned-byte ,bits))
+                         ,(integer-reader-name bytes nil)))
+         ,(generate-reader nil)))))
+
+(defmacro integer-writer (bytes)
+  "Create a function to write integers to a binary stream."
+  (let ((bits (* 8 bytes)))
+    `(progn
+      (declaim (inline ,(integer-writer-name bytes t)
+                       ,(integer-writer-name bytes nil)))
+      (defun ,(integer-writer-name bytes nil) (socket value)
+        (declare (type stream socket)
+                 (type (unsigned-byte ,bits) value)
+                 #.*optimize*)
+        ,@(if (= bytes 1)
+              `((write-byte value socket))
+              (loop :for byte :from (1- bytes) :downto 0
+                    :collect `(write-byte (ldb (byte 8 ,(* byte 8)) value)
+                               socket)))
+        (values))
+      (defun ,(integer-writer-name bytes t) (socket value)
+        (declare (type stream socket)
+                 (type (signed-byte ,bits) value)
+                 #.*optimize*)
+        ,@(if (= bytes 1)
+              `((write-byte (ldb (byte 8 0) value) socket))
+              (loop :for byte :from (1- bytes) :downto 0
+                    :collect `(write-byte (ldb (byte 8 ,(* byte 8)) value)
+                               socket)))
+        (values)))))
+
+;; All the instances of the above that we need.
+
+(integer-reader 1)
+(integer-reader 2)
+(integer-reader 4)
+(integer-reader 8)
+
+(integer-writer 1)
+(integer-writer 2)
+(integer-writer 4)
+
+(defun write-bytes (socket bytes)
+  "Write a byte-array to a stream."
+  (declare (type stream socket)
+           (type (simple-array (unsigned-byte 8)) bytes)
+           #.*optimize*)
+  (write-sequence bytes socket))
+
+(defun write-str (socket string)
+  "Write a null-terminated string to a stream \(encoding it when UTF-8
+support is enabled.)."
+  (declare (type stream socket)
+           (type string string)
+           #.*optimize*)
+  (enc-write-string string socket)
+  (write-uint1 socket 0))
+
+(declaim (ftype (function (t unsigned-byte)
+                          (simple-array (unsigned-byte 8) (*)))
+                read-bytes))
+(defun read-bytes (socket length)
+  "Read a byte array of the given length from a stream."
+  (declare (type stream socket)
+           (type fixnum length)
+           #.*optimize*)
+  (let ((result (make-array length :element-type '(unsigned-byte 8))))
+    (read-sequence result socket)
+    result))
+
+(declaim (ftype (function (t) string) read-str))
+(defun read-str (socket)
+  "Read a null-terminated string from a stream. Takes care of encoding
+when UTF-8 support is enabled."
+  (declare (type stream socket)
+           #.*optimize*)
+  (enc-read-string socket :null-terminated t))
+
+(defun skip-bytes (socket length)
+  "Skip a given number of bytes in a binary stream."
+  (declare (type stream socket)
+           (type (unsigned-byte 32) length)
+           #.*optimize*)
+  (dotimes (i length)
+    (read-byte socket)))
+
+(defun skip-str (socket)
+  "Skip a null-terminated string."
+  (declare (type stream socket)
+           #.*optimize*)
+  (loop :for char :of-type fixnum = (read-byte socket)
+        :until (zerop char)))
+
+(defun ensure-socket-is-closed (socket &amp;key abort)
+  (when (open-stream-p socket)
+    (handler-case
+        (close socket :abort abort)
+      (error (error)
+        (warn "Ignoring the error which happened while trying to close PostgreSQL socket: ~A" error)))))
+</textarea></form>
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {lineNumbers: true});
+    </script>
+
+    <p><strong>MIME types defined:</strong> <code>text/x-common-lisp</code>.</p>
+
+  </article>
diff --git a/src/main/resources/codemirror/mode/diff/diff.js b/src/main/resources/codemirror/mode/diff/diff.js
new file mode 100755
index 0000000..fe0305e
--- /dev/null
+++ b/src/main/resources/codemirror/mode/diff/diff.js
@@ -0,0 +1,47 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("diff", function() {
+
+  var TOKEN_NAMES = {
+    '+': 'positive',
+    '-': 'negative',
+    '@': 'meta'
+  };
+
+  return {
+    token: function(stream) {
+      var tw_pos = stream.string.search(/[\t ]+?$/);
+
+      if (!stream.sol() || tw_pos === 0) {
+        stream.skipToEnd();
+        return ("error " + (
+          TOKEN_NAMES[stream.string.charAt(0)] || '')).replace(/ $/, '');
+      }
+
+      var token_name = TOKEN_NAMES[stream.peek()] || stream.skipToEnd();
+
+      if (tw_pos === -1) {
+        stream.skipToEnd();
+      } else {
+        stream.pos = tw_pos;
+      }
+
+      return token_name;
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/x-diff", "diff");
+
+});
diff --git a/src/main/resources/codemirror/mode/diff/index.html b/src/main/resources/codemirror/mode/diff/index.html
new file mode 100755
index 0000000..0af611f
--- /dev/null
+++ b/src/main/resources/codemirror/mode/diff/index.html
@@ -0,0 +1,117 @@
+<!doctype html>
+
+<title>CodeMirror: Diff mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="diff.js"></script>
+<style>
+      .CodeMirror {border-top: 1px solid #ddd; border-bottom: 1px solid #ddd;}
+      span.cm-meta {color: #a0b !important;}
+      span.cm-error { background-color: black; opacity: 0.4;}
+      span.cm-error.cm-string { background-color: red; }
+      span.cm-error.cm-tag { background-color: #2b2; }
+    </style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Diff</a>
+  </ul>
+</div>
+
+<article>
+<h2>Diff mode</h2>
+<form><textarea id="code" name="code">
+diff --git a/index.html b/index.html
+index c1d9156..7764744 100644
+--- a/index.html
++++ b/index.html
+@@ -95,7 +95,8 @@ StringStream.prototype = {
+     <script>
+       var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+         lineNumbers: true,
+-        autoMatchBrackets: true
++        autoMatchBrackets: true,
++      onGutterClick: function(x){console.log(x);}
+       });
+     </script>
+   </body>
+diff --git a/lib/codemirror.js b/lib/codemirror.js
+index 04646a9..9a39cc7 100644
+--- a/lib/codemirror.js
++++ b/lib/codemirror.js
+@@ -399,10 +399,16 @@ var CodeMirror = (function() {
+     }
+ 
+     function onMouseDown(e) {
+-      var start = posFromMouse(e), last = start;    
++      var start = posFromMouse(e), last = start, target = e.target();
+       if (!start) return;
+       setCursor(start.line, start.ch, false);
+       if (e.button() != 1) return;
++      if (target.parentNode == gutter) {    
++        if (options.onGutterClick)
++          options.onGutterClick(indexOf(gutter.childNodes, target) + showingFrom);
++        return;
++      }
++
+       if (!focused) onFocus();
+ 
+       e.stop();
+@@ -808,7 +814,7 @@ var CodeMirror = (function() {
+       for (var i = showingFrom; i < showingTo; ++i) {
+         var marker = lines[i].gutterMarker;
+         if (marker) html.push('<div class="' + marker.style + '">' + htmlEscape(marker.text) + '</div>');
+-        else html.push("<div>" + (options.lineNumbers ? i + 1 : "\u00a0") + "</div>");
++        else html.push("<div>" + (options.lineNumbers ? i + options.firstLineNumber : "\u00a0") + "</div>");
+       }
+       gutter.style.display = "none"; // TODO test whether this actually helps
+       gutter.innerHTML = html.join("");
+@@ -1371,10 +1377,8 @@ var CodeMirror = (function() {
+         if (option == "parser") setParser(value);
+         else if (option === "lineNumbers") setLineNumbers(value);
+         else if (option === "gutter") setGutter(value);
+-        else if (option === "readOnly") options.readOnly = value;
+-        else if (option === "indentUnit") {options.indentUnit = indentUnit = value; setParser(options.parser);}
+-        else if (/^(?:enterMode|tabMode|indentWithTabs|readOnly|autoMatchBrackets|undoDepth)$/.test(option)) options[option] = value;
+-        else throw new Error("Can't set option " + option);
++        else if (option === "indentUnit") {options.indentUnit = value; setParser(options.parser);}
++        else options[option] = value;
+       },
+       cursorCoords: cursorCoords,
+       undo: operation(undo),
+@@ -1402,7 +1406,8 @@ var CodeMirror = (function() {
+       replaceRange: operation(replaceRange),
+ 
+       operation: function(f){return operation(f)();},
+-      refresh: function(){updateDisplay([{from: 0, to: lines.length}]);}
++      refresh: function(){updateDisplay([{from: 0, to: lines.length}]);},
++      getInputField: function(){return input;}
+     };
+     return instance;
+   }
+@@ -1420,6 +1425,7 @@ var CodeMirror = (function() {
+     readOnly: false,
+     onChange: null,
+     onCursorActivity: null,
++    onGutterClick: null,
+     autoMatchBrackets: false,
+     workTime: 200,
+     workDelay: 300,
+</textarea></form>
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {});
+    </script>
+
+    <p><strong>MIME types defined:</strong> <code>text/x-diff</code>.</p>
+
+  </article>
diff --git a/src/main/resources/codemirror/mode/forth/forth.js b/src/main/resources/codemirror/mode/forth/forth.js
new file mode 100755
index 0000000..1f519d8
--- /dev/null
+++ b/src/main/resources/codemirror/mode/forth/forth.js
@@ -0,0 +1,180 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Author: Aliaksei Chapyzhenka
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  function toWordList(words) {
+    var ret = [];
+    words.split(' ').forEach(function(e){
+      ret.push({name: e});
+    });
+    return ret;
+  }
+
+  var coreWordList = toWordList(
+'INVERT AND OR XOR\
+ 2* 2/ LSHIFT RSHIFT\
+ 0= = 0< < > U< MIN MAX\
+ 2DROP 2DUP 2OVER 2SWAP ?DUP DEPTH DROP DUP OVER ROT SWAP\
+ >R R> R@\
+ + - 1+ 1- ABS NEGATE\
+ S>D * M* UM*\
+ FM/MOD SM/REM UM/MOD */ */MOD / /MOD MOD\
+ HERE , @ ! CELL+ CELLS C, C@ C! CHARS 2@ 2!\
+ ALIGN ALIGNED +! ALLOT\
+ CHAR [CHAR] [ ] BL\
+ FIND EXECUTE IMMEDIATE COUNT LITERAL STATE\
+ ; DOES> >BODY\
+ EVALUATE\
+ SOURCE >IN\
+ <# # #S #> HOLD SIGN BASE >NUMBER HEX DECIMAL\
+ FILL MOVE\
+ . CR EMIT SPACE SPACES TYPE U. .R U.R\
+ ACCEPT\
+ TRUE FALSE\
+ <> U> 0<> 0>\
+ NIP TUCK ROLL PICK\
+ 2>R 2R@ 2R>\
+ WITHIN UNUSED MARKER\
+ I J\
+ TO\
+ COMPILE, [COMPILE]\
+ SAVE-INPUT RESTORE-INPUT\
+ PAD ERASE\
+ 2LITERAL DNEGATE\
+ D- D+ D0< D0= D2* D2/ D< D= DMAX DMIN D>S DABS\
+ M+ M*/ D. D.R 2ROT DU<\
+ CATCH THROW\
+ FREE RESIZE ALLOCATE\
+ CS-PICK CS-ROLL\
+ GET-CURRENT SET-CURRENT FORTH-WORDLIST GET-ORDER SET-ORDER\
+ PREVIOUS SEARCH-WORDLIST WORDLIST FIND ALSO ONLY FORTH DEFINITIONS ORDER\
+ -TRAILING /STRING SEARCH COMPARE CMOVE CMOVE> BLANK SLITERAL');
+
+  var immediateWordList = toWordList('IF ELSE THEN BEGIN WHILE REPEAT UNTIL RECURSE [IF] [ELSE] [THEN] ?DO DO LOOP +LOOP UNLOOP LEAVE EXIT AGAIN CASE OF ENDOF ENDCASE');
+
+  CodeMirror.defineMode('forth', function() {
+    function searchWordList (wordList, word) {
+      var i;
+      for (i = wordList.length - 1; i >= 0; i--) {
+        if (wordList[i].name === word.toUpperCase()) {
+          return wordList[i];
+        }
+      }
+      return undefined;
+    }
+  return {
+    startState: function() {
+      return {
+        state: '',
+        base: 10,
+        coreWordList: coreWordList,
+        immediateWordList: immediateWordList,
+        wordList: []
+      };
+    },
+    token: function (stream, stt) {
+      var mat;
+      if (stream.eatSpace()) {
+        return null;
+      }
+      if (stt.state === '') { // interpretation
+        if (stream.match(/^(\]|:NONAME)(\s|$)/i)) {
+          stt.state = ' compilation';
+          return 'builtin compilation';
+        }
+        mat = stream.match(/^(\:)\s+(\S+)(\s|$)+/);
+        if (mat) {
+          stt.wordList.push({name: mat[2].toUpperCase()});
+          stt.state = ' compilation';
+          return 'def' + stt.state;
+        }
+        mat = stream.match(/^(VARIABLE|2VARIABLE|CONSTANT|2CONSTANT|CREATE|POSTPONE|VALUE|WORD)\s+(\S+)(\s|$)+/i);
+        if (mat) {
+          stt.wordList.push({name: mat[2].toUpperCase()});
+          return 'def' + stt.state;
+        }
+        mat = stream.match(/^(\'|\[\'\])\s+(\S+)(\s|$)+/);
+        if (mat) {
+          return 'builtin' + stt.state;
+        }
+        } else { // compilation
+        // ; [
+        if (stream.match(/^(\;|\[)(\s)/)) {
+          stt.state = '';
+          stream.backUp(1);
+          return 'builtin compilation';
+        }
+        if (stream.match(/^(\;|\[)($)/)) {
+          stt.state = '';
+          return 'builtin compilation';
+        }
+        if (stream.match(/^(POSTPONE)\s+\S+(\s|$)+/)) {
+          return 'builtin';
+        }
+      }
+
+      // dynamic wordlist
+      mat = stream.match(/^(\S+)(\s+|$)/);
+      if (mat) {
+        if (searchWordList(stt.wordList, mat[1]) !== undefined) {
+          return 'variable' + stt.state;
+        }
+
+        // comments
+        if (mat[1] === '\\') {
+          stream.skipToEnd();
+            return 'comment' + stt.state;
+          }
+
+          // core words
+          if (searchWordList(stt.coreWordList, mat[1]) !== undefined) {
+            return 'builtin' + stt.state;
+          }
+          if (searchWordList(stt.immediateWordList, mat[1]) !== undefined) {
+            return 'keyword' + stt.state;
+          }
+
+          if (mat[1] === '(') {
+            stream.eatWhile(function (s) { return s !== ')'; });
+            stream.eat(')');
+            return 'comment' + stt.state;
+          }
+
+          // // strings
+          if (mat[1] === '.(') {
+            stream.eatWhile(function (s) { return s !== ')'; });
+            stream.eat(')');
+            return 'string' + stt.state;
+          }
+          if (mat[1] === 'S"' || mat[1] === '."' || mat[1] === 'C"') {
+            stream.eatWhile(function (s) { return s !== '"'; });
+            stream.eat('"');
+            return 'string' + stt.state;
+          }
+
+          // numbers
+          if (mat[1] - 0xfffffffff) {
+            return 'number' + stt.state;
+          }
+          // if (mat[1].match(/^[-+]?[0-9]+\.[0-9]*/)) {
+          //     return 'number' + stt.state;
+          // }
+
+          return 'atom' + stt.state;
+        }
+      }
+    };
+  });
+  CodeMirror.defineMIME("text/x-forth", "forth");
+});
diff --git a/src/main/resources/codemirror/mode/forth/index.html b/src/main/resources/codemirror/mode/forth/index.html
new file mode 100755
index 0000000..ae8cd34
--- /dev/null
+++ b/src/main/resources/codemirror/mode/forth/index.html
@@ -0,0 +1,75 @@
+<!doctype html>
+
+<title>CodeMirror: Forth mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link href='http://fonts.googleapis.com/css?family=Droid+Sans+Mono' rel='stylesheet' type='text/css'>
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<link rel=stylesheet href="../../theme/colorforth.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="forth.js"></script>
+<style>
+.CodeMirror {
+    font-family: 'Droid Sans Mono', monospace;
+    font-size: 14px;
+}
+</style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Forth</a>
+  </ul>
+</div>
+
+<article>
+
+<h2>Forth mode</h2>
+
+<form><textarea id="code" name="code">
+\ Insertion sort
+
+: cell-  1 cells - ;
+
+: insert ( start end -- start )
+  dup @ >r ( r: v )
+  begin
+    2dup <
+  while
+    r@ over cell- @ <
+  while
+    cell-
+    dup @ over cell+ !
+  repeat then
+  r> swap ! ;
+
+: sort ( array len -- )
+  1 ?do
+    dup i cells + insert
+  loop drop ;</textarea>
+  </form>
+
+<script>
+  var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+    lineNumbers: true,
+    lineWrapping: true,
+    indentUnit: 2,
+    tabSize: 2,
+    autofocus: true,
+    theme: "colorforth",
+    mode: "text/x-forth"
+  });
+</script>
+
+<p>Simple mode that handle Forth-Syntax (<a href="http://en.wikipedia.org/wiki/Forth_%28programming_language%29">Forth on WikiPedia</a>).</p>
+
+<p><strong>MIME types defined:</strong> <code>text/x-forth</code>.</p>
+
+</article>
diff --git a/src/main/resources/codemirror/mode/fortran/fortran.js b/src/main/resources/codemirror/mode/fortran/fortran.js
new file mode 100755
index 0000000..4d88f00
--- /dev/null
+++ b/src/main/resources/codemirror/mode/fortran/fortran.js
@@ -0,0 +1,188 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("fortran", function() {
+  function words(array) {
+    var keys = {};
+    for (var i = 0; i < array.length; ++i) {
+      keys[array[i]] = true;
+    }
+    return keys;
+  }
+
+  var keywords = words([
+                  "abstract", "accept", "allocatable", "allocate",
+                  "array", "assign", "asynchronous", "backspace",
+                  "bind", "block", "byte", "call", "case",
+                  "class", "close", "common", "contains",
+                  "continue", "cycle", "data", "deallocate",
+                  "decode", "deferred", "dimension", "do",
+                  "elemental", "else", "encode", "end",
+                  "endif", "entry", "enumerator", "equivalence",
+                  "exit", "external", "extrinsic", "final",
+                  "forall", "format", "function", "generic",
+                  "go", "goto", "if", "implicit", "import", "include",
+                  "inquire", "intent", "interface", "intrinsic",
+                  "module", "namelist", "non_intrinsic",
+                  "non_overridable", "none", "nopass",
+                  "nullify", "open", "optional", "options",
+                  "parameter", "pass", "pause", "pointer",
+                  "print", "private", "program", "protected",
+                  "public", "pure", "read", "recursive", "result",
+                  "return", "rewind", "save", "select", "sequence",
+                  "stop", "subroutine", "target", "then", "to", "type",
+                  "use", "value", "volatile", "where", "while",
+                  "write"]);
+  var builtins = words(["abort", "abs", "access", "achar", "acos",
+                          "adjustl", "adjustr", "aimag", "aint", "alarm",
+                          "all", "allocated", "alog", "amax", "amin",
+                          "amod", "and", "anint", "any", "asin",
+                          "associated", "atan", "besj", "besjn", "besy",
+                          "besyn", "bit_size", "btest", "cabs", "ccos",
+                          "ceiling", "cexp", "char", "chdir", "chmod",
+                          "clog", "cmplx", "command_argument_count",
+                          "complex", "conjg", "cos", "cosh", "count",
+                          "cpu_time", "cshift", "csin", "csqrt", "ctime",
+                          "c_funloc", "c_loc", "c_associated", "c_null_ptr",
+                          "c_null_funptr", "c_f_pointer", "c_null_char",
+                          "c_alert", "c_backspace", "c_form_feed",
+                          "c_new_line", "c_carriage_return",
+                          "c_horizontal_tab", "c_vertical_tab", "dabs",
+                          "dacos", "dasin", "datan", "date_and_time",
+                          "dbesj", "dbesj", "dbesjn", "dbesy", "dbesy",
+                          "dbesyn", "dble", "dcos", "dcosh", "ddim", "derf",
+                          "derfc", "dexp", "digits", "dim", "dint", "dlog",
+                          "dlog", "dmax", "dmin", "dmod", "dnint",
+                          "dot_product", "dprod", "dsign", "dsinh",
+                          "dsin", "dsqrt", "dtanh", "dtan", "dtime",
+                          "eoshift", "epsilon", "erf", "erfc", "etime",
+                          "exit", "exp", "exponent", "extends_type_of",
+                          "fdate", "fget", "fgetc", "float", "floor",
+                          "flush", "fnum", "fputc", "fput", "fraction",
+                          "fseek", "fstat", "ftell", "gerror", "getarg",
+                          "get_command", "get_command_argument",
+                          "get_environment_variable", "getcwd",
+                          "getenv", "getgid", "getlog", "getpid",
+                          "getuid", "gmtime", "hostnm", "huge", "iabs",
+                          "iachar", "iand", "iargc", "ibclr", "ibits",
+                          "ibset", "ichar", "idate", "idim", "idint",
+                          "idnint", "ieor", "ierrno", "ifix", "imag",
+                          "imagpart", "index", "int", "ior", "irand",
+                          "isatty", "ishft", "ishftc", "isign",
+                          "iso_c_binding", "is_iostat_end", "is_iostat_eor",
+                          "itime", "kill", "kind", "lbound", "len", "len_trim",
+                          "lge", "lgt", "link", "lle", "llt", "lnblnk", "loc",
+                          "log", "logical", "long", "lshift", "lstat", "ltime",
+                          "matmul", "max", "maxexponent", "maxloc", "maxval",
+                          "mclock", "merge", "move_alloc", "min", "minexponent",
+                          "minloc", "minval", "mod", "modulo", "mvbits",
+                          "nearest", "new_line", "nint", "not", "or", "pack",
+                          "perror", "precision", "present", "product", "radix",
+                          "rand", "random_number", "random_seed", "range",
+                          "real", "realpart", "rename", "repeat", "reshape",
+                          "rrspacing", "rshift", "same_type_as", "scale",
+                          "scan", "second", "selected_int_kind",
+                          "selected_real_kind", "set_exponent", "shape",
+                          "short", "sign", "signal", "sinh", "sin", "sleep",
+                          "sngl", "spacing", "spread", "sqrt", "srand", "stat",
+                          "sum", "symlnk", "system", "system_clock", "tan",
+                          "tanh", "time", "tiny", "transfer", "transpose",
+                          "trim", "ttynam", "ubound", "umask", "unlink",
+                          "unpack", "verify", "xor", "zabs", "zcos", "zexp",
+                          "zlog", "zsin", "zsqrt"]);
+
+    var dataTypes =  words(["c_bool", "c_char", "c_double", "c_double_complex",
+                     "c_float", "c_float_complex", "c_funptr", "c_int",
+                     "c_int16_t", "c_int32_t", "c_int64_t", "c_int8_t",
+                     "c_int_fast16_t", "c_int_fast32_t", "c_int_fast64_t",
+                     "c_int_fast8_t", "c_int_least16_t", "c_int_least32_t",
+                     "c_int_least64_t", "c_int_least8_t", "c_intmax_t",
+                     "c_intptr_t", "c_long", "c_long_double",
+                     "c_long_double_complex", "c_long_long", "c_ptr",
+                     "c_short", "c_signed_char", "c_size_t", "character",
+                     "complex", "double", "integer", "logical", "real"]);
+  var isOperatorChar = /[+\-*&=<>\/\:]/;
+  var litOperator = new RegExp("(\.and\.|\.or\.|\.eq\.|\.lt\.|\.le\.|\.gt\.|\.ge\.|\.ne\.|\.not\.|\.eqv\.|\.neqv\.)", "i");
+
+  function tokenBase(stream, state) {
+
+    if (stream.match(litOperator)){
+        return 'operator';
+    }
+
+    var ch = stream.next();
+    if (ch == "!") {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (ch == '"' || ch == "'") {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    }
+    if (/[\[\]\(\),]/.test(ch)) {
+      return null;
+    }
+    if (/\d/.test(ch)) {
+      stream.eatWhile(/[\w\.]/);
+      return "number";
+    }
+    if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return "operator";
+    }
+    stream.eatWhile(/[\w\$_]/);
+    var word = stream.current().toLowerCase();
+
+    if (keywords.hasOwnProperty(word)){
+            return 'keyword';
+    }
+    if (builtins.hasOwnProperty(word) || dataTypes.hasOwnProperty(word)) {
+            return 'builtin';
+    }
+    return "variable";
+  }
+
+  function tokenString(quote) {
+    return function(stream, state) {
+      var escaped = false, next, end = false;
+      while ((next = stream.next()) != null) {
+        if (next == quote && !escaped) {
+            end = true;
+            break;
+        }
+        escaped = !escaped && next == "\\";
+      }
+      if (end || !escaped) state.tokenize = null;
+      return "string";
+    };
+  }
+
+  // Interface
+
+  return {
+    startState: function() {
+      return {tokenize: null};
+    },
+
+    token: function(stream, state) {
+      if (stream.eatSpace()) return null;
+      var style = (state.tokenize || tokenBase)(stream, state);
+      if (style == "comment" || style == "meta") return style;
+      return style;
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/x-fortran", "fortran");
+
+});
diff --git a/src/main/resources/codemirror/mode/fortran/index.html b/src/main/resources/codemirror/mode/fortran/index.html
new file mode 100755
index 0000000..102e8f8
--- /dev/null
+++ b/src/main/resources/codemirror/mode/fortran/index.html
@@ -0,0 +1,81 @@
+<!doctype html>
+
+<title>CodeMirror: Fortran mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="fortran.js"></script>
+<style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Fortran</a>
+  </ul>
+</div>
+
+<article>
+<h2>Fortran mode</h2>
+
+
+<div><textarea id="code" name="code">
+! Example Fortran code
+  program average
+
+  ! Read in some numbers and take the average
+  ! As written, if there are no data points, an average of zero is returned
+  ! While this may not be desired behavior, it keeps this example simple
+
+  implicit none
+
+  real, dimension(:), allocatable :: points
+  integer                         :: number_of_points
+  real                            :: average_points=0., positive_average=0., negative_average=0.
+
+  write (*,*) "Input number of points to average:"
+  read  (*,*) number_of_points
+
+  allocate (points(number_of_points))
+
+  write (*,*) "Enter the points to average:"
+  read  (*,*) points
+
+  ! Take the average by summing points and dividing by number_of_points
+  if (number_of_points > 0) average_points = sum(points) / number_of_points
+
+  ! Now form average over positive and negative points only
+  if (count(points > 0.) > 0) then
+     positive_average = sum(points, points > 0.) / count(points > 0.)
+  end if
+
+  if (count(points < 0.) > 0) then
+     negative_average = sum(points, points < 0.) / count(points < 0.)
+  end if
+
+  deallocate (points)
+
+  ! Print result to terminal
+  write (*,'(a,g12.4)') 'Average = ', average_points
+  write (*,'(a,g12.4)') 'Average of positive points = ', positive_average
+  write (*,'(a,g12.4)') 'Average of negative points = ', negative_average
+
+  end program average
+</textarea></div>
+
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        lineNumbers: true,
+        mode: "text/x-fortran"
+      });
+    </script>
+
+    <p><strong>MIME types defined:</strong> <code>text/x-Fortran</code>.</p>
+  </article>
diff --git a/src/main/resources/codemirror/mode/index.html b/src/main/resources/codemirror/mode/index.html
new file mode 100755
index 0000000..ca89a37
--- /dev/null
+++ b/src/main/resources/codemirror/mode/index.html
@@ -0,0 +1,147 @@
+<!doctype html>
+
+<title>CodeMirror: Language Modes</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../doc/docs.css">
+
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../index.html">Home</a>
+    <li><a href="../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a class=active href="#">Language modes</a>
+  </ul>
+</div>
+
+<article>
+
+  <h2>Language modes</h2>
+
+  <p>This is a list of every mode in the distribution. Each mode lives
+in a subdirectory of the <code>mode/</code> directory, and typically
+defines a single JavaScript file that implements the mode. Loading
+such file will make the language available to CodeMirror, through
+the <a href="../doc/manual.html#option_mode"><code>mode</code></a>
+option.</p>
+
+  <div style="-webkit-columns: 100px 2; -moz-columns: 100px 2; columns: 100px 2;">
+    <ul style="margin-top: 0">
+      <li><a href="apl/index.html">APL</a></li>
+      <li><a href="asn.1/index.html">ASN.1</a></li>
+      <li><a href="asterisk/index.html">Asterisk dialplan</a></li>
+      <li><a href="brainfuck/index.html">Brainfuck</a></li>
+      <li><a href="clike/index.html">C, C++, C#</a></li>
+      <li><a href="clojure/index.html">Clojure</a></li>
+      <li><a href="cmake/index.html">CMake</a></li>
+      <li><a href="cobol/index.html">COBOL</a></li>
+      <li><a href="coffeescript/index.html">CoffeeScript</a></li>
+      <li><a href="commonlisp/index.html">Common Lisp</a></li>
+      <li><a href="css/index.html">CSS</a></li>
+      <li><a href="cypher/index.html">Cypher</a></li>
+      <li><a href="python/index.html">Cython</a></li>
+      <li><a href="d/index.html">D</a></li>
+      <li><a href="dart/index.html">Dart</a></li>
+      <li><a href="django/index.html">Django</a> (templating language)</li>
+      <li><a href="dockerfile/index.html">Dockerfile</a></li>
+      <li><a href="diff/index.html">diff</a></li>
+      <li><a href="dtd/index.html">DTD</a></li>
+      <li><a href="dylan/index.html">Dylan</a></li>
+      <li><a href="ebnf/index.html">EBNF</a></li>
+      <li><a href="ecl/index.html">ECL</a></li>
+      <li><a href="eiffel/index.html">Eiffel</a></li>
+      <li><a href="elm/index.html">Elm</a></li>
+      <li><a href="erlang/index.html">Erlang</a></li>
+      <li><a href="factor/index.html">Factor</a></li>
+      <li><a href="forth/index.html">Forth</a></li>
+      <li><a href="fortran/index.html">Fortran</a></li>
+      <li><a href="mllike/index.html">F#</a></li>
+      <li><a href="gas/index.html">Gas</a> (AT&amp;T-style assembly)</li>
+      <li><a href="gherkin/index.html">Gherkin</a></li>
+      <li><a href="go/index.html">Go</a></li>
+      <li><a href="groovy/index.html">Groovy</a></li>
+      <li><a href="haml/index.html">HAML</a></li>
+      <li><a href="handlebars/index.html">Handlebars</a></li>
+      <li><a href="haskell/index.html">Haskell</a></li>
+      <li><a href="haxe/index.html">Haxe</a></li>
+      <li><a href="htmlembedded/index.html">HTML embedded</a> (JSP, ASP.NET)</li>
+      <li><a href="htmlmixed/index.html">HTML mixed-mode</a></li>
+      <li><a href="http/index.html">HTTP</a></li>
+      <li><a href="idl/index.html">IDL</a></li>
+      <li><a href="clike/index.html">Java</a></li>
+      <li><a href="jade/index.html">Jade</a></li>
+      <li><a href="javascript/index.html">JavaScript</a></li>
+      <li><a href="jinja2/index.html">Jinja2</a></li>
+      <li><a href="julia/index.html">Julia</a></li>
+      <li><a href="kotlin/index.html">Kotlin</a></li>
+      <li><a href="css/less.html">LESS</a></li>
+      <li><a href="livescript/index.html">LiveScript</a></li>
+      <li><a href="lua/index.html">Lua</a></li>
+      <li><a href="markdown/index.html">Markdown</a> (<a href="gfm/index.html">GitHub-flavour</a>)</li>
+      <li><a href="mathematica/index.html">Mathematica</a></li>
+      <li><a href="mirc/index.html">mIRC</a></li>
+      <li><a href="modelica/index.html">Modelica</a></li>
+      <li><a href="mumps/index.html">MUMPS</a></li>
+      <li><a href="nginx/index.html">Nginx</a></li>
+      <li><a href="ntriples/index.html">NTriples</a></li>
+      <li><a href="clike/index.html">Objective C</a></li>
+      <li><a href="mllike/index.html">OCaml</a></li>
+      <li><a href="octave/index.html">Octave</a> (MATLAB)</li>
+      <li><a href="pascal/index.html">Pascal</a></li>
+      <li><a href="pegjs/index.html">PEG.js</a></li>
+      <li><a href="perl/index.html">Perl</a></li>
+      <li><a href="asciiarmor/index.html">PGP (ASCII armor)</a></li>
+      <li><a href="php/index.html">PHP</a></li>
+      <li><a href="pig/index.html">Pig Latin</a></li>
+      <li><a href="properties/index.html">Properties files</a></li>
+      <li><a href="puppet/index.html">Puppet</a></li>
+      <li><a href="python/index.html">Python</a></li>
+      <li><a href="q/index.html">Q</a></li>
+      <li><a href="r/index.html">R</a></li>
+      <li><a href="rpm/index.html">RPM</a></li>
+      <li><a href="rst/index.html">reStructuredText</a></li>
+      <li><a href="ruby/index.html">Ruby</a></li>
+      <li><a href="rust/index.html">Rust</a></li>
+      <li><a href="sass/index.html">Sass</a></li>
+      <li><a href="spreadsheet/index.html">Spreadsheet</a></li>
+      <li><a href="clike/scala.html">Scala</a></li>
+      <li><a href="scheme/index.html">Scheme</a></li>
+      <li><a href="css/scss.html">SCSS</a></li>
+      <li><a href="shell/index.html">Shell</a></li>
+      <li><a href="sieve/index.html">Sieve</a></li>
+      <li><a href="slim/index.html">Slim</a></li>
+      <li><a href="smalltalk/index.html">Smalltalk</a></li>
+      <li><a href="smarty/index.html">Smarty</a></li>
+      <li><a href="solr/index.html">Solr</a></li>
+      <li><a href="soy/index.html">Soy</a></li>
+      <li><a href="stylus/index.html">Stylus</a></li>
+      <li><a href="sql/index.html">SQL</a> (several dialects)</li>
+      <li><a href="sparql/index.html">SPARQL</a></li>
+      <li><a href="swift/index.html">Swift</a></li>
+      <li><a href="stex/index.html">sTeX, LaTeX</a></li>
+      <li><a href="tcl/index.html">Tcl</a></li>
+      <li><a href="textile/index.html">Textile</a></li>
+      <li><a href="tiddlywiki/index.html">Tiddlywiki</a></li>
+      <li><a href="tiki/index.html">Tiki wiki</a></li>
+      <li><a href="toml/index.html">TOML</a></li>
+      <li><a href="tornado/index.html">Tornado</a> (templating language)</li>
+      <li><a href="troff/index.html">troff</a> (for manpages)</li>
+      <li><a href="ttcn/index.html">TTCN</a></li>
+      <li><a href="ttcn-cfg/index.html">TTCN Configuration</a></li>
+      <li><a href="turtle/index.html">Turtle</a></li>
+      <li><a href="twig/index.html">Twig</a></li>
+      <li><a href="vb/index.html">VB.NET</a></li>
+      <li><a href="vbscript/index.html">VBScript</a></li>
+      <li><a href="velocity/index.html">Velocity</a></li>
+      <li><a href="verilog/index.html">Verilog/SystemVerilog</a></li>
+      <li><a href="xml/index.html">XML/HTML</a></li>
+      <li><a href="xquery/index.html">XQuery</a></li>
+      <li><a href="yaml/index.html">YAML</a></li>
+      <li><a href="z80/index.html">Z80</a></li>
+    </ul>
+  </div>
+
+</article>
diff --git a/src/main/resources/codemirror/mode/meta.js b/src/main/resources/codemirror/mode/meta.js
new file mode 100755
index 0000000..bf0929e
--- /dev/null
+++ b/src/main/resources/codemirror/mode/meta.js
@@ -0,0 +1,189 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.modeInfo = [
+    {name: "APL", mime: "text/apl", mode: "apl", ext: ["dyalog", "apl"]},
+    {name: "PGP", mimes: ["application/pgp", "application/pgp-keys", "application/pgp-signature"], mode: "asciiarmor", ext: ["pgp"]},
+    {name: "ASN.1", mime: "text/x-ttcn-asn", mode: "asn.1", ext: ["asn", "asn1"]},
+    {name: "Asterisk", mime: "text/x-asterisk", mode: "asterisk", file: /^extensions\.conf$/i},
+    {name: "Brainfuck", mime: "text/x-brainfuck", mode: "brainfuck", ext: ["b", "bf"]},
+    {name: "C", mime: "text/x-csrc", mode: "clike", ext: ["c", "h"]},
+    {name: "C++", mime: "text/x-c++src", mode: "clike", ext: ["cpp", "c++", "cc", "cxx", "hpp", "h++", "hh", "hxx"], alias: ["cpp"]},
+    {name: "Cobol", mime: "text/x-cobol", mode: "cobol", ext: ["cob", "cpy"]},
+    {name: "C#", mime: "text/x-csharp", mode: "clike", ext: ["cs"], alias: ["csharp"]},
+    {name: "Clojure", mime: "text/x-clojure", mode: "clojure", ext: ["clj"]},
+    {name: "CMake", mime: "text/x-cmake", mode: "cmake", ext: ["cmake", "cmake.in"], file: /^CMakeLists.txt$/},
+    {name: "CoffeeScript", mime: "text/x-coffeescript", mode: "coffeescript", ext: ["coffee"], alias: ["coffee", "coffee-script"]},
+    {name: "Common Lisp", mime: "text/x-common-lisp", mode: "commonlisp", ext: ["cl", "lisp", "el"], alias: ["lisp"]},
+    {name: "Cypher", mime: "application/x-cypher-query", mode: "cypher", ext: ["cyp", "cypher"]},
+    {name: "Cython", mime: "text/x-cython", mode: "python", ext: ["pyx", "pxd", "pxi"]},
+    {name: "CSS", mime: "text/css", mode: "css", ext: ["css"]},
+    {name: "CQL", mime: "text/x-cassandra", mode: "sql", ext: ["cql"]},
+    {name: "D", mime: "text/x-d", mode: "d", ext: ["d"]},
+    {name: "Dart", mimes: ["application/dart", "text/x-dart"], mode: "dart", ext: ["dart"]},
+    {name: "diff", mime: "text/x-diff", mode: "diff", ext: ["diff", "patch"]},
+    {name: "Django", mime: "text/x-django", mode: "django"},
+    {name: "Dockerfile", mime: "text/x-dockerfile", mode: "dockerfile", file: /^Dockerfile$/},
+    {name: "DTD", mime: "application/xml-dtd", mode: "dtd", ext: ["dtd"]},
+    {name: "Dylan", mime: "text/x-dylan", mode: "dylan", ext: ["dylan", "dyl", "intr"]},
+    {name: "EBNF", mime: "text/x-ebnf", mode: "ebnf"},
+    {name: "ECL", mime: "text/x-ecl", mode: "ecl", ext: ["ecl"]},
+    {name: "Eiffel", mime: "text/x-eiffel", mode: "eiffel", ext: ["e"]},
+    {name: "Elm", mime: "text/x-elm", mode: "elm", ext: ["elm"]},
+    {name: "Embedded Javascript", mime: "application/x-ejs", mode: "htmlembedded", ext: ["ejs"]},
+    {name: "Embedded Ruby", mime: "application/x-erb", mode: "htmlembedded", ext: ["erb"]},
+    {name: "Erlang", mime: "text/x-erlang", mode: "erlang", ext: ["erl"]},
+    {name: "Factor", mime: "text/x-factor", mode: "factor", ext: ["factor"]},
+    {name: "Forth", mime: "text/x-forth", mode: "forth", ext: ["forth", "fth", "4th"]},
+    {name: "Fortran", mime: "text/x-fortran", mode: "fortran", ext: ["f", "for", "f77", "f90"]},
+    {name: "F#", mime: "text/x-fsharp", mode: "mllike", ext: ["fs"], alias: ["fsharp"]},
+    {name: "Gas", mime: "text/x-gas", mode: "gas", ext: ["s"]},
+    {name: "Gherkin", mime: "text/x-feature", mode: "gherkin", ext: ["feature"]},
+    {name: "GitHub Flavored Markdown", mime: "text/x-gfm", mode: "gfm", file: /^(readme|contributing|history).md$/i},
+    {name: "Go", mime: "text/x-go", mode: "go", ext: ["go"]},
+    {name: "Groovy", mime: "text/x-groovy", mode: "groovy", ext: ["groovy"]},
+    {name: "HAML", mime: "text/x-haml", mode: "haml", ext: ["haml"]},
+    {name: "Haskell", mime: "text/x-haskell", mode: "haskell", ext: ["hs"]},
+    {name: "Haxe", mime: "text/x-haxe", mode: "haxe", ext: ["hx"]},
+    {name: "HXML", mime: "text/x-hxml", mode: "haxe", ext: ["hxml"]},
+    {name: "ASP.NET", mime: "application/x-aspx", mode: "htmlembedded", ext: ["aspx"], alias: ["asp", "aspx"]},
+    {name: "HTML", mime: "text/html", mode: "htmlmixed", ext: ["html", "htm"], alias: ["xhtml"]},
+    {name: "HTTP", mime: "message/http", mode: "http"},
+    {name: "IDL", mime: "text/x-idl", mode: "idl", ext: ["pro"]},
+    {name: "Jade", mime: "text/x-jade", mode: "jade", ext: ["jade"]},
+    {name: "Java", mime: "text/x-java", mode: "clike", ext: ["java"]},
+    {name: "Java Server Pages", mime: "application/x-jsp", mode: "htmlembedded", ext: ["jsp"], alias: ["jsp"]},
+    {name: "JavaScript", mimes: ["text/javascript", "text/ecmascript", "application/javascript", "application/x-javascript", "application/ecmascript"],
+     mode: "javascript", ext: ["js"], alias: ["ecmascript", "js", "node"]},
+    {name: "JSON", mimes: ["application/json", "application/x-json"], mode: "javascript", ext: ["json", "map"], alias: ["json5"]},
+    {name: "JSON-LD", mime: "application/ld+json", mode: "javascript", ext: ["jsonld"], alias: ["jsonld"]},
+    {name: "Jinja2", mime: "null", mode: "jinja2"},
+    {name: "Julia", mime: "text/x-julia", mode: "julia", ext: ["jl"]},
+    {name: "Kotlin", mime: "text/x-kotlin", mode: "kotlin", ext: ["kt"]},
+    {name: "LESS", mime: "text/x-less", mode: "css", ext: ["less"]},
+    {name: "LiveScript", mime: "text/x-livescript", mode: "livescript", ext: ["ls"], alias: ["ls"]},
+    {name: "Lua", mime: "text/x-lua", mode: "lua", ext: ["lua"]},
+    {name: "Markdown", mime: "text/x-markdown", mode: "markdown", ext: ["markdown", "md", "mkd"]},
+    {name: "mIRC", mime: "text/mirc", mode: "mirc"},
+    {name: "MariaDB SQL", mime: "text/x-mariadb", mode: "sql"},
+    {name: "Mathematica", mime: "text/x-mathematica", mode: "mathematica", ext: ["m", "nb"]},
+    {name: "Modelica", mime: "text/x-modelica", mode: "modelica", ext: ["mo"]},
+    {name: "MUMPS", mime: "text/x-mumps", mode: "mumps"},
+    {name: "MS SQL", mime: "text/x-mssql", mode: "sql"},
+    {name: "MySQL", mime: "text/x-mysql", mode: "sql"},
+    {name: "Nginx", mime: "text/x-nginx-conf", mode: "nginx", file: /nginx.*\.conf$/i},
+    {name: "NTriples", mime: "text/n-triples", mode: "ntriples", ext: ["nt"]},
+    {name: "Objective C", mime: "text/x-objectivec", mode: "clike", ext: ["m", "mm"]},
+    {name: "OCaml", mime: "text/x-ocaml", mode: "mllike", ext: ["ml", "mli", "mll", "mly"]},
+    {name: "Octave", mime: "text/x-octave", mode: "octave", ext: ["m"]},
+    {name: "Pascal", mime: "text/x-pascal", mode: "pascal", ext: ["p", "pas"]},
+    {name: "PEG.js", mime: "null", mode: "pegjs", ext: ["jsonld"]},
+    {name: "Perl", mime: "text/x-perl", mode: "perl", ext: ["pl", "pm"]},
+    {name: "PHP", mime: "application/x-httpd-php", mode: "php", ext: ["php", "php3", "php4", "php5", "phtml"]},
+    {name: "Pig", mime: "text/x-pig", mode: "pig", ext: ["pig"]},
+    {name: "Plain Text", mime: "text/plain", mode: "null", ext: ["txt", "text", "conf", "def", "list", "log"]},
+    {name: "PLSQL", mime: "text/x-plsql", mode: "sql", ext: ["pls"]},
+    {name: "Properties files", mime: "text/x-properties", mode: "properties", ext: ["properties", "ini", "in"], alias: ["ini", "properties"]},
+    {name: "Python", mime: "text/x-python", mode: "python", ext: ["py", "pyw"]},
+    {name: "Puppet", mime: "text/x-puppet", mode: "puppet", ext: ["pp"]},
+    {name: "Q", mime: "text/x-q", mode: "q", ext: ["q"]},
+    {name: "R", mime: "text/x-rsrc", mode: "r", ext: ["r"], alias: ["rscript"]},
+    {name: "reStructuredText", mime: "text/x-rst", mode: "rst", ext: ["rst"], alias: ["rst"]},
+    {name: "RPM Changes", mime: "text/x-rpm-changes", mode: "rpm"},
+    {name: "RPM Spec", mime: "text/x-rpm-spec", mode: "rpm", ext: ["spec"]},
+    {name: "Ruby", mime: "text/x-ruby", mode: "ruby", ext: ["rb"], alias: ["jruby", "macruby", "rake", "rb", "rbx"]},
+    {name: "Rust", mime: "text/x-rustsrc", mode: "rust", ext: ["rs"]},
+    {name: "Sass", mime: "text/x-sass", mode: "sass", ext: ["sass"]},
+    {name: "Scala", mime: "text/x-scala", mode: "clike", ext: ["scala"]},
+    {name: "Scheme", mime: "text/x-scheme", mode: "scheme", ext: ["scm", "ss"]},
+    {name: "SCSS", mime: "text/x-scss", mode: "css", ext: ["scss"]},
+    {name: "Shell", mime: "text/x-sh", mode: "shell", ext: ["sh", "ksh", "bash"], alias: ["bash", "sh", "zsh"]},
+    {name: "Sieve", mime: "application/sieve", mode: "sieve", ext: ["siv", "sieve"]},
+    {name: "Slim", mimes: ["text/x-slim", "application/x-slim"], mode: "slim", ext: ["slim"]},
+    {name: "Smalltalk", mime: "text/x-stsrc", mode: "smalltalk", ext: ["st"]},
+    {name: "Smarty", mime: "text/x-smarty", mode: "smarty", ext: ["tpl"]},
+    {name: "Solr", mime: "text/x-solr", mode: "solr"},
+    {name: "Soy", mime: "text/x-soy", mode: "soy", ext: ["soy"], alias: ["closure template"]},
+    {name: "SPARQL", mime: "application/sparql-query", mode: "sparql", ext: ["rq", "sparql"], alias: ["sparul"]},
+    {name: "Spreadsheet", mime: "text/x-spreadsheet", mode: "spreadsheet", alias: ["excel", "formula"]},
+    {name: "SQL", mime: "text/x-sql", mode: "sql", ext: ["sql"]},
+    {name: "Swift", mime: "text/x-swift", mode: "swift", ext: ["swift"]},
+    {name: "MariaDB", mime: "text/x-mariadb", mode: "sql"},
+    {name: "sTeX", mime: "text/x-stex", mode: "stex"},
+    {name: "LaTeX", mime: "text/x-latex", mode: "stex", ext: ["text", "ltx"], alias: ["tex"]},
+    {name: "SystemVerilog", mime: "text/x-systemverilog", mode: "verilog", ext: ["v"]},
+    {name: "Tcl", mime: "text/x-tcl", mode: "tcl", ext: ["tcl"]},
+    {name: "Textile", mime: "text/x-textile", mode: "textile", ext: ["textile"]},
+    {name: "TiddlyWiki ", mime: "text/x-tiddlywiki", mode: "tiddlywiki"},
+    {name: "Tiki wiki", mime: "text/tiki", mode: "tiki"},
+    {name: "TOML", mime: "text/x-toml", mode: "toml", ext: ["toml"]},
+    {name: "Tornado", mime: "text/x-tornado", mode: "tornado"},
+    {name: "troff", mime: "troff", mode: "troff", ext: ["1", "2", "3", "4", "5", "6", "7", "8", "9"]},
+    {name: "TTCN", mime: "text/x-ttcn", mode: "ttcn", ext: ["ttcn", "ttcn3", "ttcnpp"]},
+    {name: "TTCN_CFG", mime: "text/x-ttcn-cfg", mode: "ttcn-cfg", ext: ["cfg"]},
+    {name: "Turtle", mime: "text/turtle", mode: "turtle", ext: ["ttl"]},
+    {name: "TypeScript", mime: "application/typescript", mode: "javascript", ext: ["ts"], alias: ["ts"]},
+    {name: "Twig", mime: "text/x-twig", mode: "twig"},
+    {name: "VB.NET", mime: "text/x-vb", mode: "vb", ext: ["vb"]},
+    {name: "VBScript", mime: "text/vbscript", mode: "vbscript", ext: ["vbs"]},
+    {name: "Velocity", mime: "text/velocity", mode: "velocity", ext: ["vtl"]},
+    {name: "Verilog", mime: "text/x-verilog", mode: "verilog", ext: ["v"]},
+    {name: "XML", mimes: ["application/xml", "text/xml"], mode: "xml", ext: ["xml", "xsl", "xsd"], alias: ["rss", "wsdl", "xsd"]},
+    {name: "XQuery", mime: "application/xquery", mode: "xquery", ext: ["xy", "xquery"]},
+    {name: "YAML", mime: "text/x-yaml", mode: "yaml", ext: ["yaml", "yml"], alias: ["yml"]},
+    {name: "Z80", mime: "text/x-z80", mode: "z80", ext: ["z80"]}
+  ];
+  // Ensure all modes have a mime property for backwards compatibility
+  for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+    var info = CodeMirror.modeInfo[i];
+    if (info.mimes) info.mime = info.mimes[0];
+  }
+
+  CodeMirror.findModeByMIME = function(mime) {
+    mime = mime.toLowerCase();
+    for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+      var info = CodeMirror.modeInfo[i];
+      if (info.mime == mime) return info;
+      if (info.mimes) for (var j = 0; j < info.mimes.length; j++)
+        if (info.mimes[j] == mime) return info;
+    }
+  };
+
+  CodeMirror.findModeByExtension = function(ext) {
+    for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+      var info = CodeMirror.modeInfo[i];
+      if (info.ext) for (var j = 0; j < info.ext.length; j++)
+        if (info.ext[j] == ext) return info;
+    }
+  };
+
+  CodeMirror.findModeByFileName = function(filename) {
+    for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+      var info = CodeMirror.modeInfo[i];
+      if (info.file && info.file.test(filename)) return info;
+    }
+    var dot = filename.lastIndexOf(".");
+    var ext = dot > -1 && filename.substring(dot + 1, filename.length);
+    if (ext) return CodeMirror.findModeByExtension(ext);
+  };
+
+  CodeMirror.findModeByName = function(name) {
+    name = name.toLowerCase();
+    for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+      var info = CodeMirror.modeInfo[i];
+      if (info.name.toLowerCase() == name) return info;
+      if (info.alias) for (var j = 0; j < info.alias.length; j++)
+        if (info.alias[j].toLowerCase() == name) return info;
+    }
+  };
+});
diff --git a/src/main/resources/codemirror/mode/pascal/index.html b/src/main/resources/codemirror/mode/pascal/index.html
new file mode 100755
index 0000000..f8a99ad
--- /dev/null
+++ b/src/main/resources/codemirror/mode/pascal/index.html
@@ -0,0 +1,61 @@
+<!doctype html>
+
+<title>CodeMirror: Pascal mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="pascal.js"></script>
+<style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Pascal</a>
+  </ul>
+</div>
+
+<article>
+<h2>Pascal mode</h2>
+
+
+<div><textarea id="code" name="code">
+(* Example Pascal code *)
+
+while a <> b do writeln('Waiting');
+ 
+if a > b then 
+  writeln('Condition met')
+else 
+  writeln('Condition not met');
+ 
+for i := 1 to 10 do 
+  writeln('Iteration: ', i:1);
+ 
+repeat
+  a := a + 1
+until a = 10;
+ 
+case i of
+  0: write('zero');
+  1: write('one');
+  2: write('two')
+end;
+</textarea></div>
+
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        lineNumbers: true,
+        mode: "text/x-pascal"
+      });
+    </script>
+
+    <p><strong>MIME types defined:</strong> <code>text/x-pascal</code>.</p>
+  </article>
diff --git a/src/main/resources/codemirror/mode/pascal/pascal.js b/src/main/resources/codemirror/mode/pascal/pascal.js
new file mode 100755
index 0000000..2d0c3d4
--- /dev/null
+++ b/src/main/resources/codemirror/mode/pascal/pascal.js
@@ -0,0 +1,109 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("pascal", function() {
+  function words(str) {
+    var obj = {}, words = str.split(" ");
+    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+    return obj;
+  }
+  var keywords = words("and array begin case const div do downto else end file for forward integer " +
+                       "boolean char function goto if in label mod nil not of or packed procedure " +
+                       "program record repeat set string then to type until var while with");
+  var atoms = {"null": true};
+
+  var isOperatorChar = /[+\-*&%=<>!?|\/]/;
+
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+    if (ch == "#" && state.startOfLine) {
+      stream.skipToEnd();
+      return "meta";
+    }
+    if (ch == '"' || ch == "'") {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    }
+    if (ch == "(" && stream.eat("*")) {
+      state.tokenize = tokenComment;
+      return tokenComment(stream, state);
+    }
+    if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+      return null;
+    }
+    if (/\d/.test(ch)) {
+      stream.eatWhile(/[\w\.]/);
+      return "number";
+    }
+    if (ch == "/") {
+      if (stream.eat("/")) {
+        stream.skipToEnd();
+        return "comment";
+      }
+    }
+    if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return "operator";
+    }
+    stream.eatWhile(/[\w\$_]/);
+    var cur = stream.current();
+    if (keywords.propertyIsEnumerable(cur)) return "keyword";
+    if (atoms.propertyIsEnumerable(cur)) return "atom";
+    return "variable";
+  }
+
+  function tokenString(quote) {
+    return function(stream, state) {
+      var escaped = false, next, end = false;
+      while ((next = stream.next()) != null) {
+        if (next == quote && !escaped) {end = true; break;}
+        escaped = !escaped && next == "\\";
+      }
+      if (end || !escaped) state.tokenize = null;
+      return "string";
+    };
+  }
+
+  function tokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if (ch == ")" && maybeEnd) {
+        state.tokenize = null;
+        break;
+      }
+      maybeEnd = (ch == "*");
+    }
+    return "comment";
+  }
+
+  // Interface
+
+  return {
+    startState: function() {
+      return {tokenize: null};
+    },
+
+    token: function(stream, state) {
+      if (stream.eatSpace()) return null;
+      var style = (state.tokenize || tokenBase)(stream, state);
+      if (style == "comment" || style == "meta") return style;
+      return style;
+    },
+
+    electricChars: "{}"
+  };
+});
+
+CodeMirror.defineMIME("text/x-pascal", "pascal");
+
+});
diff --git a/src/main/resources/codemirror/mode/smalltalk/index.html b/src/main/resources/codemirror/mode/smalltalk/index.html
new file mode 100755
index 0000000..2155ebc
--- /dev/null
+++ b/src/main/resources/codemirror/mode/smalltalk/index.html
@@ -0,0 +1,68 @@
+<!doctype html>
+
+<title>CodeMirror: Smalltalk mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="../../addon/edit/matchbrackets.js"></script>
+<script src="smalltalk.js"></script>
+<style>
+      .CodeMirror {border: 2px solid #dee; border-right-width: 10px;}
+      .CodeMirror-gutter {border: none; background: #dee;}
+      .CodeMirror-gutter pre {color: white; font-weight: bold;}
+    </style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Smalltalk</a>
+  </ul>
+</div>
+
+<article>
+<h2>Smalltalk mode</h2>
+<form><textarea id="code" name="code">
+" 
+    This is a test of the Smalltalk code
+"
+Seaside.WAComponent subclass: #MyCounter [
+    | count |
+    MyCounter class &gt;&gt; canBeRoot [ ^true ]
+
+    initialize [
+        super initialize.
+        count := 0.
+    ]
+    states [ ^{ self } ]
+    renderContentOn: html [
+        html heading: count.
+        html anchor callback: [ count := count + 1 ]; with: '++'.
+        html space.
+        html anchor callback: [ count := count - 1 ]; with: '--'.
+    ]
+]
+
+MyCounter registerAsApplication: 'mycounter'
+</textarea></form>
+
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        lineNumbers: true,
+        matchBrackets: true,
+        mode: "text/x-stsrc",
+        indentUnit: 4
+      });
+    </script>
+
+    <p>Simple Smalltalk mode.</p>
+
+    <p><strong>MIME types defined:</strong> <code>text/x-stsrc</code>.</p>
+  </article>
diff --git a/src/main/resources/codemirror/mode/smalltalk/smalltalk.js b/src/main/resources/codemirror/mode/smalltalk/smalltalk.js
new file mode 100755
index 0000000..bb510ba
--- /dev/null
+++ b/src/main/resources/codemirror/mode/smalltalk/smalltalk.js
@@ -0,0 +1,168 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode('smalltalk', function(config) {
+
+  var specialChars = /[+\-\/\\*~<>=@%|&?!.,:;^]/;
+  var keywords = /true|false|nil|self|super|thisContext/;
+
+  var Context = function(tokenizer, parent) {
+    this.next = tokenizer;
+    this.parent = parent;
+  };
+
+  var Token = function(name, context, eos) {
+    this.name = name;
+    this.context = context;
+    this.eos = eos;
+  };
+
+  var State = function() {
+    this.context = new Context(next, null);
+    this.expectVariable = true;
+    this.indentation = 0;
+    this.userIndentationDelta = 0;
+  };
+
+  State.prototype.userIndent = function(indentation) {
+    this.userIndentationDelta = indentation > 0 ? (indentation / config.indentUnit - this.indentation) : 0;
+  };
+
+  var next = function(stream, context, state) {
+    var token = new Token(null, context, false);
+    var aChar = stream.next();
+
+    if (aChar === '"') {
+      token = nextComment(stream, new Context(nextComment, context));
+
+    } else if (aChar === '\'') {
+      token = nextString(stream, new Context(nextString, context));
+
+    } else if (aChar === '#') {
+      if (stream.peek() === '\'') {
+        stream.next();
+        token = nextSymbol(stream, new Context(nextSymbol, context));
+      } else {
+        if (stream.eatWhile(/[^\s.{}\[\]()]/))
+          token.name = 'string-2';
+        else
+          token.name = 'meta';
+      }
+
+    } else if (aChar === '$') {
+      if (stream.next() === '<') {
+        stream.eatWhile(/[^\s>]/);
+        stream.next();
+      }
+      token.name = 'string-2';
+
+    } else if (aChar === '|' && state.expectVariable) {
+      token.context = new Context(nextTemporaries, context);
+
+    } else if (/[\[\]{}()]/.test(aChar)) {
+      token.name = 'bracket';
+      token.eos = /[\[{(]/.test(aChar);
+
+      if (aChar === '[') {
+        state.indentation++;
+      } else if (aChar === ']') {
+        state.indentation = Math.max(0, state.indentation - 1);
+      }
+
+    } else if (specialChars.test(aChar)) {
+      stream.eatWhile(specialChars);
+      token.name = 'operator';
+      token.eos = aChar !== ';'; // ; cascaded message expression
+
+    } else if (/\d/.test(aChar)) {
+      stream.eatWhile(/[\w\d]/);
+      token.name = 'number';
+
+    } else if (/[\w_]/.test(aChar)) {
+      stream.eatWhile(/[\w\d_]/);
+      token.name = state.expectVariable ? (keywords.test(stream.current()) ? 'keyword' : 'variable') : null;
+
+    } else {
+      token.eos = state.expectVariable;
+    }
+
+    return token;
+  };
+
+  var nextComment = function(stream, context) {
+    stream.eatWhile(/[^"]/);
+    return new Token('comment', stream.eat('"') ? context.parent : context, true);
+  };
+
+  var nextString = function(stream, context) {
+    stream.eatWhile(/[^']/);
+    return new Token('string', stream.eat('\'') ? context.parent : context, false);
+  };
+
+  var nextSymbol = function(stream, context) {
+    stream.eatWhile(/[^']/);
+    return new Token('string-2', stream.eat('\'') ? context.parent : context, false);
+  };
+
+  var nextTemporaries = function(stream, context) {
+    var token = new Token(null, context, false);
+    var aChar = stream.next();
+
+    if (aChar === '|') {
+      token.context = context.parent;
+      token.eos = true;
+
+    } else {
+      stream.eatWhile(/[^|]/);
+      token.name = 'variable';
+    }
+
+    return token;
+  };
+
+  return {
+    startState: function() {
+      return new State;
+    },
+
+    token: function(stream, state) {
+      state.userIndent(stream.indentation());
+
+      if (stream.eatSpace()) {
+        return null;
+      }
+
+      var token = state.context.next(stream, state.context, state);
+      state.context = token.context;
+      state.expectVariable = token.eos;
+
+      return token.name;
+    },
+
+    blankLine: function(state) {
+      state.userIndent(0);
+    },
+
+    indent: function(state, textAfter) {
+      var i = state.context.next === next && textAfter && textAfter.charAt(0) === ']' ? -1 : state.userIndentationDelta;
+      return (state.indentation + i) * config.indentUnit;
+    },
+
+    electricChars: ']'
+  };
+
+});
+
+CodeMirror.defineMIME('text/x-stsrc', {name: 'smalltalk'});
+
+});
diff --git a/src/main/resources/codemirror/mode/turtle/index.html b/src/main/resources/codemirror/mode/turtle/index.html
new file mode 100755
index 0000000..a4962b6
--- /dev/null
+++ b/src/main/resources/codemirror/mode/turtle/index.html
@@ -0,0 +1,50 @@
+<!doctype html>
+
+<title>CodeMirror: Turtle mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="turtle.js"></script>
+<style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Turtle</a>
+  </ul>
+</div>
+
+<article>
+<h2>Turtle mode</h2>
+<form><textarea id="code" name="code">
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix geo: <http://www.w3.org/2003/01/geo/wgs84_pos#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+<http://purl.org/net/bsletten> 
+    a foaf:Person;
+    foaf:interest <http://www.w3.org/2000/01/sw/>;
+    foaf:based_near [
+        geo:lat "34.0736111" ;
+        geo:lon "-118.3994444"
+   ]
+
+</textarea></form>
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        mode: "text/turtle",
+        matchBrackets: true
+      });
+    </script>
+
+    <p><strong>MIME types defined:</strong> <code>text/turtle</code>.</p>
+
+  </article>
diff --git a/src/main/resources/codemirror/mode/turtle/turtle.js b/src/main/resources/codemirror/mode/turtle/turtle.js
new file mode 100755
index 0000000..0988f0a
--- /dev/null
+++ b/src/main/resources/codemirror/mode/turtle/turtle.js
@@ -0,0 +1,162 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("turtle", function(config) {
+  var indentUnit = config.indentUnit;
+  var curPunc;
+
+  function wordRegexp(words) {
+    return new RegExp("^(?:" + words.join("|") + ")$", "i");
+  }
+  var ops = wordRegexp([]);
+  var keywords = wordRegexp(["@prefix", "@base", "a"]);
+  var operatorChars = /[*+\-<>=&|]/;
+
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+    curPunc = null;
+    if (ch == "<" && !stream.match(/^[\s\u00a0=]/, false)) {
+      stream.match(/^[^\s\u00a0>]*>?/);
+      return "atom";
+    }
+    else if (ch == "\"" || ch == "'") {
+      state.tokenize = tokenLiteral(ch);
+      return state.tokenize(stream, state);
+    }
+    else if (/[{}\(\),\.;\[\]]/.test(ch)) {
+      curPunc = ch;
+      return null;
+    }
+    else if (ch == "#") {
+      stream.skipToEnd();
+      return "comment";
+    }
+    else if (operatorChars.test(ch)) {
+      stream.eatWhile(operatorChars);
+      return null;
+    }
+    else if (ch == ":") {
+          return "operator";
+        } else {
+      stream.eatWhile(/[_\w\d]/);
+      if(stream.peek() == ":") {
+        return "variable-3";
+      } else {
+             var word = stream.current();
+
+             if(keywords.test(word)) {
+                        return "meta";
+             }
+
+             if(ch >= "A" && ch <= "Z") {
+                    return "comment";
+                 } else {
+                        return "keyword";
+                 }
+      }
+      var word = stream.current();
+      if (ops.test(word))
+        return null;
+      else if (keywords.test(word))
+        return "meta";
+      else
+        return "variable";
+    }
+  }
+
+  function tokenLiteral(quote) {
+    return function(stream, state) {
+      var escaped = false, ch;
+      while ((ch = stream.next()) != null) {
+        if (ch == quote && !escaped) {
+          state.tokenize = tokenBase;
+          break;
+        }
+        escaped = !escaped && ch == "\\";
+      }
+      return "string";
+    };
+  }
+
+  function pushContext(state, type, col) {
+    state.context = {prev: state.context, indent: state.indent, col: col, type: type};
+  }
+  function popContext(state) {
+    state.indent = state.context.indent;
+    state.context = state.context.prev;
+  }
+
+  return {
+    startState: function() {
+      return {tokenize: tokenBase,
+              context: null,
+              indent: 0,
+              col: 0};
+    },
+
+    token: function(stream, state) {
+      if (stream.sol()) {
+        if (state.context && state.context.align == null) state.context.align = false;
+        state.indent = stream.indentation();
+      }
+      if (stream.eatSpace()) return null;
+      var style = state.tokenize(stream, state);
+
+      if (style != "comment" && state.context && state.context.align == null && state.context.type != "pattern") {
+        state.context.align = true;
+      }
+
+      if (curPunc == "(") pushContext(state, ")", stream.column());
+      else if (curPunc == "[") pushContext(state, "]", stream.column());
+      else if (curPunc == "{") pushContext(state, "}", stream.column());
+      else if (/[\]\}\)]/.test(curPunc)) {
+        while (state.context && state.context.type == "pattern") popContext(state);
+        if (state.context && curPunc == state.context.type) popContext(state);
+      }
+      else if (curPunc == "." && state.context && state.context.type == "pattern") popContext(state);
+      else if (/atom|string|variable/.test(style) && state.context) {
+        if (/[\}\]]/.test(state.context.type))
+          pushContext(state, "pattern", stream.column());
+        else if (state.context.type == "pattern" && !state.context.align) {
+          state.context.align = true;
+          state.context.col = stream.column();
+        }
+      }
+
+      return style;
+    },
+
+    indent: function(state, textAfter) {
+      var firstChar = textAfter && textAfter.charAt(0);
+      var context = state.context;
+      if (/[\]\}]/.test(firstChar))
+        while (context && context.type == "pattern") context = context.prev;
+
+      var closing = context && firstChar == context.type;
+      if (!context)
+        return 0;
+      else if (context.type == "pattern")
+        return context.col;
+      else if (context.align)
+        return context.col + (closing ? 0 : 1);
+      else
+        return context.indent + (closing ? 0 : indentUnit);
+    },
+
+    lineComment: "#"
+  };
+});
+
+CodeMirror.defineMIME("text/turtle", "turtle");
+
+});
diff --git a/src/main/resources/codemirror/mode/z80/index.html b/src/main/resources/codemirror/mode/z80/index.html
new file mode 100755
index 0000000..a41b747
--- /dev/null
+++ b/src/main/resources/codemirror/mode/z80/index.html
@@ -0,0 +1,53 @@
+<!doctype html>
+
+<title>CodeMirror: Z80 assembly mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="z80.js"></script>
+<style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Z80 assembly</a>
+  </ul>
+</div>
+
+<article>
+<h2>Z80 assembly mode</h2>
+
+
+<div><textarea id="code" name="code">
+#include    "ti83plus.inc"
+#define     progStart   $9D95
+    .org progStart-2
+    .db $BB,$6D
+
+    bcall(_ClrLCDFull)
+    ld hl,0
+    ld (CurCol),hl
+    ld hl,Message
+    bcall(_PutS) ; Displays the string
+    bcall(_NewLine)
+    ret
+Message:
+    .db "Hello world!",0
+</textarea></div>
+
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        lineNumbers: true
+      });
+    </script>
+
+    <p><strong>MIME types defined:</strong> <code>text/x-z80</code>, <code>text/x-ez80</code>.</p>
+  </article>
diff --git a/src/main/resources/codemirror/mode/z80/z80.js b/src/main/resources/codemirror/mode/z80/z80.js
new file mode 100755
index 0000000..aae7021
--- /dev/null
+++ b/src/main/resources/codemirror/mode/z80/z80.js
@@ -0,0 +1,116 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+  mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+  define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+  mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode('z80', function(_config, parserConfig) {
+  var ez80 = parserConfig.ez80;
+  var keywords1, keywords2;
+  if (ez80) {
+    keywords1 = /^(exx?|(ld|cp)([di]r?)?|[lp]ea|pop|push|ad[cd]|cpl|daa|dec|inc|neg|sbc|sub|and|bit|[cs]cf|x?or|res|set|r[lr]c?a?|r[lr]d|s[lr]a|srl|djnz|nop|[de]i|halt|im|in([di]mr?|ir?|irx|2r?)|ot(dmr?|[id]rx|imr?)|out(0?|[di]r?|[di]2r?)|tst(io)?|slp)(\.([sl]?i)?[sl])?\b/i;
+    keywords2 = /^(((call|j[pr]|rst|ret[in]?)(\.([sl]?i)?[sl])?)|(rs|st)mix)\b/i;
+  } else {
+    keywords1 = /^(exx?|(ld|cp|in)([di]r?)?|pop|push|ad[cd]|cpl|daa|dec|inc|neg|sbc|sub|and|bit|[cs]cf|x?or|res|set|r[lr]c?a?|r[lr]d|s[lr]a|srl|djnz|nop|rst|[de]i|halt|im|ot[di]r|out[di]?)\b/i;
+    keywords2 = /^(call|j[pr]|ret[in]?|b_?(call|jump))\b/i;
+  }
+
+  var variables1 = /^(af?|bc?|c|de?|e|hl?|l|i[xy]?|r|sp)\b/i;
+  var variables2 = /^(n?[zc]|p[oe]?|m)\b/i;
+  var errors = /^([hl][xy]|i[xy][hl]|slia|sll)\b/i;
+  var numbers = /^([\da-f]+h|[0-7]+o|[01]+b|\d+d?)\b/i;
+
+  return {
+    startState: function() {
+      return {
+        context: 0
+      };
+    },
+    token: function(stream, state) {
+      if (!stream.column())
+        state.context = 0;
+
+      if (stream.eatSpace())
+        return null;
+
+      var w;
+
+      if (stream.eatWhile(/\w/)) {
+        if (ez80 && stream.eat('.')) {
+          stream.eatWhile(/\w/);
+        }
+        w = stream.current();
+
+        if (stream.indentation()) {
+          if ((state.context == 1 || state.context == 4) && variables1.test(w)) {
+            state.context = 4;
+            return 'var2';
+          }
+
+          if (state.context == 2 && variables2.test(w)) {
+            state.context = 4;
+            return 'var3';
+          }
+
+          if (keywords1.test(w)) {
+            state.context = 1;
+            return 'keyword';
+          } else if (keywords2.test(w)) {
+            state.context = 2;
+            return 'keyword';
+          } else if (state.context == 4 && numbers.test(w)) {
+            return 'number';
+          }
+
+          if (errors.test(w))
+            return 'error';
+        } else if (stream.match(numbers)) {
+          return 'number';
+        } else {
+          return null;
+        }
+      } else if (stream.eat(';')) {
+        stream.skipToEnd();
+        return 'comment';
+      } else if (stream.eat('"')) {
+        while (w = stream.next()) {
+          if (w == '"')
+            break;
+
+          if (w == '\\')
+            stream.next();
+        }
+        return 'string';
+      } else if (stream.eat('\'')) {
+        if (stream.match(/\\?.'/))
+          return 'number';
+      } else if (stream.eat('.') || stream.sol() && stream.eat('#')) {
+        state.context = 5;
+
+        if (stream.eatWhile(/\w/))
+          return 'def';
+      } else if (stream.eat('$')) {
+        if (stream.eatWhile(/[\da-f]/i))
+          return 'number';
+      } else if (stream.eat('%')) {
+        if (stream.eatWhile(/[01]/))
+          return 'number';
+      } else {
+        stream.next();
+      }
+      return null;
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/x-z80", "z80");
+CodeMirror.defineMIME("text/x-ez80", { name: "z80", ez80: true });
+
+});
diff --git a/src/main/resources/codemirror/theme/3024-day.css b/src/main/resources/codemirror/theme/3024-day.css
new file mode 100755
index 0000000..1eb109e
--- /dev/null
+++ b/src/main/resources/codemirror/theme/3024-day.css
@@ -0,0 +1,41 @@
+/*
+
+    Name:       3024 day
+    Author:     Jan T. Sott (http://github.com/idleberg)
+
+    CodeMirror template by Jan T. Sott (https://github.com/idleberg/base16-codemirror)
+    Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16)
+
+*/
+
+.cm-s-3024-day.CodeMirror {background: #f7f7f7; color: #3a3432;}
+.cm-s-3024-day div.CodeMirror-selected {background: #d6d5d4 !important;}
+
+.cm-s-3024-day .CodeMirror-line::selection, .cm-s-3024-day .CodeMirror-line > span::selection, .cm-s-3024-day .CodeMirror-line > span > span::selection { background: #d6d5d4; }
+.cm-s-3024-day .CodeMirror-line::-moz-selection, .cm-s-3024-day .CodeMirror-line > span::-moz-selection, .cm-s-3024-day .CodeMirror-line > span > span::selection { background: #d9d9d9; }
+
+.cm-s-3024-day .CodeMirror-gutters {background: #f7f7f7; border-right: 0px;}
+.cm-s-3024-day .CodeMirror-guttermarker { color: #db2d20; }
+.cm-s-3024-day .CodeMirror-guttermarker-subtle { color: #807d7c; }
+.cm-s-3024-day .CodeMirror-linenumber {color: #807d7c;}
+
+.cm-s-3024-day .CodeMirror-cursor {border-left: 1px solid #5c5855 !important;}
+
+.cm-s-3024-day span.cm-comment {color: #cdab53;}
+.cm-s-3024-day span.cm-atom {color: #a16a94;}
+.cm-s-3024-day span.cm-number {color: #a16a94;}
+
+.cm-s-3024-day span.cm-property, .cm-s-3024-day span.cm-attribute {color: #01a252;}
+.cm-s-3024-day span.cm-keyword {color: #db2d20;}
+.cm-s-3024-day span.cm-string {color: #fded02;}
+
+.cm-s-3024-day span.cm-variable {color: #01a252;}
+.cm-s-3024-day span.cm-variable-2 {color: #01a0e4;}
+.cm-s-3024-day span.cm-def {color: #e8bbd0;}
+.cm-s-3024-day span.cm-bracket {color: #3a3432;}
+.cm-s-3024-day span.cm-tag {color: #db2d20;}
+.cm-s-3024-day span.cm-link {color: #a16a94;}
+.cm-s-3024-day span.cm-error {background: #db2d20; color: #5c5855;}
+
+.cm-s-3024-day .CodeMirror-activeline-background {background: #e8f2ff !important;}
+.cm-s-3024-day .CodeMirror-matchingbracket { text-decoration: underline; color: #a16a94 !important;}
diff --git a/src/main/resources/codemirror/theme/3024-night.css b/src/main/resources/codemirror/theme/3024-night.css
new file mode 100755
index 0000000..36bb8b4
--- /dev/null
+++ b/src/main/resources/codemirror/theme/3024-night.css
@@ -0,0 +1,39 @@
+/*
+
+    Name:       3024 night
+    Author:     Jan T. Sott (http://github.com/idleberg)
+
+    CodeMirror template by Jan T. Sott (https://github.com/idleberg/base16-codemirror)
+    Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16)
+
+*/
+
+.cm-s-3024-night.CodeMirror {background: #090300; color: #d6d5d4;}
+.cm-s-3024-night div.CodeMirror-selected {background: #3a3432 !important;}
+.cm-s-3024-night .CodeMirror-line::selection, .cm-s-3024-night .CodeMirror-line > span::selection, .cm-s-3024-night .CodeMirror-line > span > span::selection { background: rgba(58, 52, 50, .99); }
+.cm-s-3024-night .CodeMirror-line::-moz-selection, .cm-s-3024-night .CodeMirror-line > span::-moz-selection, .cm-s-3024-night .CodeMirror-line > span > span::-moz-selection { background: rgba(58, 52, 50, .99); }
+.cm-s-3024-night .CodeMirror-gutters {background: #090300; border-right: 0px;}
+.cm-s-3024-night .CodeMirror-guttermarker { color: #db2d20; }
+.cm-s-3024-night .CodeMirror-guttermarker-subtle { color: #5c5855; }
+.cm-s-3024-night .CodeMirror-linenumber {color: #5c5855;}
+
+.cm-s-3024-night .CodeMirror-cursor {border-left: 1px solid #807d7c !important;}
+
+.cm-s-3024-night span.cm-comment {color: #cdab53;}
+.cm-s-3024-night span.cm-atom {color: #a16a94;}
+.cm-s-3024-night span.cm-number {color: #a16a94;}
+
+.cm-s-3024-night span.cm-property, .cm-s-3024-night span.cm-attribute {color: #01a252;}
+.cm-s-3024-night span.cm-keyword {color: #db2d20;}
+.cm-s-3024-night span.cm-string {color: #fded02;}
+
+.cm-s-3024-night span.cm-variable {color: #01a252;}
+.cm-s-3024-night span.cm-variable-2 {color: #01a0e4;}
+.cm-s-3024-night span.cm-def {color: #e8bbd0;}
+.cm-s-3024-night span.cm-bracket {color: #d6d5d4;}
+.cm-s-3024-night span.cm-tag {color: #db2d20;}
+.cm-s-3024-night span.cm-link {color: #a16a94;}
+.cm-s-3024-night span.cm-error {background: #db2d20; color: #807d7c;}
+
+.cm-s-3024-night .CodeMirror-activeline-background {background: #2F2F2F !important;}
+.cm-s-3024-night .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
diff --git a/src/main/resources/codemirror/theme/ambiance-mobile.css b/src/main/resources/codemirror/theme/ambiance-mobile.css
new file mode 100755
index 0000000..88d332e
--- /dev/null
+++ b/src/main/resources/codemirror/theme/ambiance-mobile.css
@@ -0,0 +1,5 @@
+.cm-s-ambiance.CodeMirror {
+  -webkit-box-shadow: none;
+  -moz-box-shadow: none;
+  box-shadow: none;
+}
diff --git a/src/main/resources/codemirror/theme/ambiance.css b/src/main/resources/codemirror/theme/ambiance.css
new file mode 100755
index 0000000..0e68f75
--- /dev/null
+++ b/src/main/resources/codemirror/theme/ambiance.css
@@ -0,0 +1,76 @@
+/* ambiance theme for codemirror */
+
+/* Color scheme */
+
+.cm-s-ambiance .cm-header {color: blue;}
+.cm-s-ambiance .cm-quote { color: #24C2C7; }
+
+.cm-s-ambiance .cm-keyword { color: #cda869; }
+.cm-s-ambiance .cm-atom { color: #CF7EA9; }
+.cm-s-ambiance .cm-number { color: #78CF8A; }
+.cm-s-ambiance .cm-def { color: #aac6e3; }
+.cm-s-ambiance .cm-variable { color: #ffb795; }
+.cm-s-ambiance .cm-variable-2 { color: #eed1b3; }
+.cm-s-ambiance .cm-variable-3 { color: #faded3; }
+.cm-s-ambiance .cm-property { color: #eed1b3; }
+.cm-s-ambiance .cm-operator {color: #fa8d6a;}
+.cm-s-ambiance .cm-comment { color: #555; font-style:italic; }
+.cm-s-ambiance .cm-string { color: #8f9d6a; }
+.cm-s-ambiance .cm-string-2 { color: #9d937c; }
+.cm-s-ambiance .cm-meta { color: #D2A8A1; }
+.cm-s-ambiance .cm-qualifier { color: yellow; }
+.cm-s-ambiance .cm-builtin { color: #9999cc; }
+.cm-s-ambiance .cm-bracket { color: #24C2C7; }
+.cm-s-ambiance .cm-tag { color: #fee4ff }
+.cm-s-ambiance .cm-attribute {  color: #9B859D; }
+.cm-s-ambiance .cm-hr { color: pink; }
+.cm-s-ambiance .cm-link { color: #F4C20B; }
+.cm-s-ambiance .cm-special { color: #FF9D00; }
+.cm-s-ambiance .cm-error { color: #AF2018; }
+
+.cm-s-ambiance .CodeMirror-matchingbracket { color: #0f0; }
+.cm-s-ambiance .CodeMirror-nonmatchingbracket { color: #f22; }
+
+.cm-s-ambiance .CodeMirror-selected { background: rgba(255, 255, 255, 0.15); }
+.cm-s-ambiance.CodeMirror-focused .CodeMirror-selected { background: rgba(255, 255, 255, 0.10); }
+.cm-s-ambiance .CodeMirror-line::selection, .cm-s-ambiance .CodeMirror-line > span::selection, .cm-s-ambiance .CodeMirror-line > span > span::selection { background: rgba(255, 255, 255, 0.10); }
+.cm-s-ambiance .CodeMirror-line::-moz-selection, .cm-s-ambiance .CodeMirror-line > span::-moz-selection, .cm-s-ambiance .CodeMirror-line > span > span::-moz-selection { background: rgba(255, 255, 255, 0.10); }
+
+/* Editor styling */
+
+.cm-s-ambiance.CodeMirror {
+  line-height: 1.40em;
+  color: #E6E1DC;
+  background-color: #202020;
+  -webkit-box-shadow: inset 0 0 10px black;
+  -moz-box-shadow: inset 0 0 10px black;
+  box-shadow: inset 0 0 10px black;
+}
+
+.cm-s-ambiance .CodeMirror-gutters {
+  background: #3D3D3D;
+  border-right: 1px solid #4D4D4D;
+  box-shadow: 0 10px 20px black;
+}
+
+.cm-s-ambiance .CodeMirror-linenumber {
+  text-shadow: 0px 1px 1px #4d4d4d;
+  color: #111;
+  padding: 0 5px;
+}
+
+.cm-s-ambiance .CodeMirror-guttermarker { color: #aaa; }
+.cm-s-ambiance .CodeMirror-guttermarker-subtle { color: #111; }
+
+.cm-s-ambiance .CodeMirror-lines .CodeMirror-cursor {
+  border-left: 1px solid #7991E8;
+}
+
+.cm-s-ambiance .CodeMirror-activeline-background {
+  background: none repeat scroll 0% 0% rgba(255, 255, 255, 0.031);
+}
+
+.cm-s-ambiance.CodeMirror,
+.cm-s-ambiance .CodeMirror-gutters {
+  background-image: url("data:image/png;base64,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");
+}
diff --git a/src/main/resources/codemirror/theme/base16-dark.css b/src/main/resources/codemirror/theme/base16-dark.css
new file mode 100755
index 0000000..fb79fae
--- /dev/null
+++ b/src/main/resources/codemirror/theme/base16-dark.css
@@ -0,0 +1,38 @@
+/*
+
+    Name:       Base16 Default Dark
+    Author:     Chris Kempson (http://chriskempson.com)
+
+    CodeMirror template by Jan T. Sott (https://github.com/idleberg/base16-chrome-devtools)
+    Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16)
+
+*/
+
+.cm-s-base16-dark.CodeMirror {background: #151515; color: #e0e0e0;}
+.cm-s-base16-dark div.CodeMirror-selected {background: #303030 !important;}
+.cm-s-base16-dark .CodeMirror-line::selection, .cm-s-base16-dark .CodeMirror-line > span::selection, .cm-s-base16-dark .CodeMirror-line > span > span::selection { background: rgba(48, 48, 48, .99); }
+.cm-s-base16-dark .CodeMirror-line::-moz-selection, .cm-s-base16-dark .CodeMirror-line > span::-moz-selection, .cm-s-base16-dark .CodeMirror-line > span > span::-moz-selection { background: rgba(48, 48, 48, .99); }
+.cm-s-base16-dark .CodeMirror-gutters {background: #151515; border-right: 0px;}
+.cm-s-base16-dark .CodeMirror-guttermarker { color: #ac4142; }
+.cm-s-base16-dark .CodeMirror-guttermarker-subtle { color: #505050; }
+.cm-s-base16-dark .CodeMirror-linenumber {color: #505050;}
+.cm-s-base16-dark .CodeMirror-cursor {border-left: 1px solid #b0b0b0 !important;}
+
+.cm-s-base16-dark span.cm-comment {color: #8f5536;}
+.cm-s-base16-dark span.cm-atom {color: #aa759f;}
+.cm-s-base16-dark span.cm-number {color: #aa759f;}
+
+.cm-s-base16-dark span.cm-property, .cm-s-base16-dark span.cm-attribute {color: #90a959;}
+.cm-s-base16-dark span.cm-keyword {color: #ac4142;}
+.cm-s-base16-dark span.cm-string {color: #f4bf75;}
+
+.cm-s-base16-dark span.cm-variable {color: #90a959;}
+.cm-s-base16-dark span.cm-variable-2 {color: #6a9fb5;}
+.cm-s-base16-dark span.cm-def {color: #d28445;}
+.cm-s-base16-dark span.cm-bracket {color: #e0e0e0;}
+.cm-s-base16-dark span.cm-tag {color: #ac4142;}
+.cm-s-base16-dark span.cm-link {color: #aa759f;}
+.cm-s-base16-dark span.cm-error {background: #ac4142; color: #b0b0b0;}
+
+.cm-s-base16-dark .CodeMirror-activeline-background {background: #202020 !important;}
+.cm-s-base16-dark .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
diff --git a/src/main/resources/codemirror/theme/base16-light.css b/src/main/resources/codemirror/theme/base16-light.css
new file mode 100755
index 0000000..46508e0
--- /dev/null
+++ b/src/main/resources/codemirror/theme/base16-light.css
@@ -0,0 +1,38 @@
+/*
+
+    Name:       Base16 Default Light
+    Author:     Chris Kempson (http://chriskempson.com)
+
+    CodeMirror template by Jan T. Sott (https://github.com/idleberg/base16-chrome-devtools)
+    Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16)
+
+*/
+
+.cm-s-base16-light.CodeMirror {background: #f5f5f5; color: #202020;}
+.cm-s-base16-light div.CodeMirror-selected {background: #e0e0e0 !important;}
+.cm-s-base16-light .CodeMirror-line::selection, .cm-s-base16-light .CodeMirror-line > span::selection, .cm-s-base16-light .CodeMirror-line > span > span::selection { background: #e0e0e0; }
+.cm-s-base16-light .CodeMirror-line::-moz-selection, .cm-s-base16-light .CodeMirror-line > span::-moz-selection, .cm-s-base16-light .CodeMirror-line > span > span::-moz-selection { background: #e0e0e0; }
+.cm-s-base16-light .CodeMirror-gutters {background: #f5f5f5; border-right: 0px;}
+.cm-s-base16-light .CodeMirror-guttermarker { color: #ac4142; }
+.cm-s-base16-light .CodeMirror-guttermarker-subtle { color: #b0b0b0; }
+.cm-s-base16-light .CodeMirror-linenumber {color: #b0b0b0;}
+.cm-s-base16-light .CodeMirror-cursor {border-left: 1px solid #505050 !important;}
+
+.cm-s-base16-light span.cm-comment {color: #8f5536;}
+.cm-s-base16-light span.cm-atom {color: #aa759f;}
+.cm-s-base16-light span.cm-number {color: #aa759f;}
+
+.cm-s-base16-light span.cm-property, .cm-s-base16-light span.cm-attribute {color: #90a959;}
+.cm-s-base16-light span.cm-keyword {color: #ac4142;}
+.cm-s-base16-light span.cm-string {color: #f4bf75;}
+
+.cm-s-base16-light span.cm-variable {color: #90a959;}
+.cm-s-base16-light span.cm-variable-2 {color: #6a9fb5;}
+.cm-s-base16-light span.cm-def {color: #d28445;}
+.cm-s-base16-light span.cm-bracket {color: #202020;}
+.cm-s-base16-light span.cm-tag {color: #ac4142;}
+.cm-s-base16-light span.cm-link {color: #aa759f;}
+.cm-s-base16-light span.cm-error {background: #ac4142; color: #505050;}
+
+.cm-s-base16-light .CodeMirror-activeline-background {background: #DDDCDC !important;}
+.cm-s-base16-light .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
diff --git a/src/main/resources/codemirror/theme/blackboard.css b/src/main/resources/codemirror/theme/blackboard.css
new file mode 100755
index 0000000..6de11dd
--- /dev/null
+++ b/src/main/resources/codemirror/theme/blackboard.css
@@ -0,0 +1,32 @@
+/* Port of TextMate's Blackboard theme */
+
+.cm-s-blackboard.CodeMirror { background: #0C1021; color: #F8F8F8; }
+.cm-s-blackboard .CodeMirror-selected { background: #253B76 !important; }
+.cm-s-blackboard .CodeMirror-line::selection, .cm-s-blackboard .CodeMirror-line > span::selection, .cm-s-blackboard .CodeMirror-line > span > span::selection { background: rgba(37, 59, 118, .99); }
+.cm-s-blackboard .CodeMirror-line::-moz-selection, .cm-s-blackboard .CodeMirror-line > span::-moz-selection, .cm-s-blackboard .CodeMirror-line > span > span::-moz-selection { background: rgba(37, 59, 118, .99); }
+.cm-s-blackboard .CodeMirror-gutters { background: #0C1021; border-right: 0; }
+.cm-s-blackboard .CodeMirror-guttermarker { color: #FBDE2D; }
+.cm-s-blackboard .CodeMirror-guttermarker-subtle { color: #888; }
+.cm-s-blackboard .CodeMirror-linenumber { color: #888; }
+.cm-s-blackboard .CodeMirror-cursor { border-left: 1px solid #A7A7A7 !important; }
+
+.cm-s-blackboard .cm-keyword { color: #FBDE2D; }
+.cm-s-blackboard .cm-atom { color: #D8FA3C; }
+.cm-s-blackboard .cm-number { color: #D8FA3C; }
+.cm-s-blackboard .cm-def { color: #8DA6CE; }
+.cm-s-blackboard .cm-variable { color: #FF6400; }
+.cm-s-blackboard .cm-operator { color: #FBDE2D;}
+.cm-s-blackboard .cm-comment { color: #AEAEAE; }
+.cm-s-blackboard .cm-string { color: #61CE3C; }
+.cm-s-blackboard .cm-string-2 { color: #61CE3C; }
+.cm-s-blackboard .cm-meta { color: #D8FA3C; }
+.cm-s-blackboard .cm-builtin { color: #8DA6CE; }
+.cm-s-blackboard .cm-tag { color: #8DA6CE; }
+.cm-s-blackboard .cm-attribute { color: #8DA6CE; }
+.cm-s-blackboard .cm-header { color: #FF6400; }
+.cm-s-blackboard .cm-hr { color: #AEAEAE; }
+.cm-s-blackboard .cm-link { color: #8DA6CE; }
+.cm-s-blackboard .cm-error { background: #9D1E15; color: #F8F8F8; }
+
+.cm-s-blackboard .CodeMirror-activeline-background {background: #3C3636 !important;}
+.cm-s-blackboard .CodeMirror-matchingbracket {outline:1px solid grey;color:white !important}
\ No newline at end of file
diff --git a/src/main/resources/codemirror/theme/cobalt.css b/src/main/resources/codemirror/theme/cobalt.css
new file mode 100755
index 0000000..b6eebcf
--- /dev/null
+++ b/src/main/resources/codemirror/theme/cobalt.css
@@ -0,0 +1,25 @@
+.cm-s-cobalt.CodeMirror { background: #002240; color: white; }
+.cm-s-cobalt div.CodeMirror-selected { background: #b36539 !important; }
+.cm-s-cobalt .CodeMirror-line::selection, .cm-s-cobalt .CodeMirror-line > span::selection, .cm-s-cobalt .CodeMirror-line > span > span::selection { background: rgba(179, 101, 57, .99); }
+.cm-s-cobalt .CodeMirror-line::-moz-selection, .cm-s-cobalt .CodeMirror-line > span::-moz-selection, .cm-s-cobalt .CodeMirror-line > span > span::-moz-selection { background: rgba(179, 101, 57, .99); }
+.cm-s-cobalt .CodeMirror-gutters { background: #002240; border-right: 1px solid #aaa; }
+.cm-s-cobalt .CodeMirror-guttermarker { color: #ffee80; }
+.cm-s-cobalt .CodeMirror-guttermarker-subtle { color: #d0d0d0; }
+.cm-s-cobalt .CodeMirror-linenumber { color: #d0d0d0; }
+.cm-s-cobalt .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-cobalt span.cm-comment { color: #08f; }
+.cm-s-cobalt span.cm-atom { color: #845dc4; }
+.cm-s-cobalt span.cm-number, .cm-s-cobalt span.cm-attribute { color: #ff80e1; }
+.cm-s-cobalt span.cm-keyword { color: #ffee80; }
+.cm-s-cobalt span.cm-string { color: #3ad900; }
+.cm-s-cobalt span.cm-meta { color: #ff9d00; }
+.cm-s-cobalt span.cm-variable-2, .cm-s-cobalt span.cm-tag { color: #9effff; }
+.cm-s-cobalt span.cm-variable-3, .cm-s-cobalt span.cm-def { color: white; }
+.cm-s-cobalt span.cm-bracket { color: #d8d8d8; }
+.cm-s-cobalt span.cm-builtin, .cm-s-cobalt span.cm-special { color: #ff9e59; }
+.cm-s-cobalt span.cm-link { color: #845dc4; }
+.cm-s-cobalt span.cm-error { color: #9d1e15; }
+
+.cm-s-cobalt .CodeMirror-activeline-background {background: #002D57 !important;}
+.cm-s-cobalt .CodeMirror-matchingbracket {outline:1px solid grey;color:white !important}
diff --git a/src/main/resources/codemirror/theme/colorforth.css b/src/main/resources/codemirror/theme/colorforth.css
new file mode 100755
index 0000000..73fbf80
--- /dev/null
+++ b/src/main/resources/codemirror/theme/colorforth.css
@@ -0,0 +1,33 @@
+.cm-s-colorforth.CodeMirror { background: #000000; color: #f8f8f8; }
+.cm-s-colorforth .CodeMirror-gutters { background: #0a001f; border-right: 1px solid #aaa; }
+.cm-s-colorforth .CodeMirror-guttermarker { color: #FFBD40; }
+.cm-s-colorforth .CodeMirror-guttermarker-subtle { color: #78846f; }
+.cm-s-colorforth .CodeMirror-linenumber { color: #bababa; }
+.cm-s-colorforth .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-colorforth span.cm-comment     { color: #ededed; }
+.cm-s-colorforth span.cm-def         { color: #ff1c1c; font-weight:bold; }
+.cm-s-colorforth span.cm-keyword     { color: #ffd900; }
+.cm-s-colorforth span.cm-builtin     { color: #00d95a; }
+.cm-s-colorforth span.cm-variable    { color: #73ff00; }
+.cm-s-colorforth span.cm-string      { color: #007bff; }
+.cm-s-colorforth span.cm-number      { color: #00c4ff; }
+.cm-s-colorforth span.cm-atom        { color: #606060; }
+
+.cm-s-colorforth span.cm-variable-2  { color: #EEE; }
+.cm-s-colorforth span.cm-variable-3  { color: #DDD; }
+.cm-s-colorforth span.cm-property    {}
+.cm-s-colorforth span.cm-operator    {}
+
+.cm-s-colorforth span.cm-meta        { color: yellow; }
+.cm-s-colorforth span.cm-qualifier   { color: #FFF700; }
+.cm-s-colorforth span.cm-bracket     { color: #cc7; }
+.cm-s-colorforth span.cm-tag         { color: #FFBD40; }
+.cm-s-colorforth span.cm-attribute   { color: #FFF700; }
+.cm-s-colorforth span.cm-error       { color: #f00; }
+
+.cm-s-colorforth .CodeMirror-selected { background: #333d53 !important; }
+
+.cm-s-colorforth span.cm-compilation { background: rgba(255, 255, 255, 0.12); }
+
+.cm-s-colorforth .CodeMirror-activeline-background {background: #253540 !important;}
diff --git a/src/main/resources/codemirror/theme/dracula.css b/src/main/resources/codemirror/theme/dracula.css
new file mode 100755
index 0000000..5badef2
--- /dev/null
+++ b/src/main/resources/codemirror/theme/dracula.css
@@ -0,0 +1,87 @@
+/*
+
+    Name:       dracula
+    Author:     Michael Kaminsky (http://github.com/mkaminsky11)
+
+    Original dracula color scheme by Zeno Rocha (https://github.com/zenorocha/dracula-theme)
+
+*/
+
+
+.cm-s-dracula.CodeMirror, .cm-s-dracula .CodeMirror-gutters {
+  background-color: #282a36 !important;
+  color: #f8f8f2 !important;
+  border: none;
+}
+.cm-s-dracula .CodeMirror-gutters{
+  color: #282a36;
+}
+.cm-s-dracula .CodeMirror-cursor {
+  border-left: solid thin #f8f8f0 !important;
+}
+.cm-s-dracula .CodeMirror-linenumber {
+  color: #6D8A88;
+}
+.cm-s-dracula.CodeMirror-focused .CodeMirror-selected {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-dracula .CodeMirror-line::selection, .cm-s-dracula .CodeMirror-line > span::selection, .cm-s-dracula .CodeMirror-line > span > span::selection {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-dracula .CodeMirror-line::-moz-selection, .cm-s-dracula .CodeMirror-line > span::-moz-selection, .cm-s-dracula .CodeMirror-line > span > span::-moz-selection {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-dracula span.cm-comment {
+  color: #6272a4;
+}
+.cm-s-dracula span.cm-string, .cm-s-dracula span.cm-string-2 {
+  color: #f1fa8c;
+}
+.cm-s-dracula span.cm-number {
+  color: #bd93f9;
+}
+.cm-s-dracula span.cm-variable {
+  color: #50fa7b;
+}
+.cm-s-dracula span.cm-variable-2 {
+  color: white;
+}
+.cm-s-dracula span.cm-def {
+  color: #ffb86c;
+}
+.cm-s-dracula span.cm-keyword {
+  color: #ff79c6;
+}
+.cm-s-dracula span.cm-operator {
+  color: #ff79c6;
+}
+.cm-s-dracula span.cm-keyword {
+  color: #ff79c6;
+}
+.cm-s-dracula span.cm-atom {
+  color: #bd93f9;
+}
+.cm-s-dracula span.cm-meta {
+  color: #f8f8f2;
+}
+.cm-s-dracula span.cm-tag {
+  color: #ff79c6;
+}
+.cm-s-dracula span.cm-attribute {
+  color: #50fa7b;
+}
+.cm-s-dracula span.cm-qualifier {
+  color: #50fa7b;
+}
+.cm-s-dracula span.cm-property {
+  color: #66d9ef;
+}
+.cm-s-dracula span.cm-builtin {
+  color: #50fa7b;
+}
+.cm-s-dracula span.cm-variable-3 {
+  color: #50fa7b;
+}
+
+.cm-s-dracula .CodeMirror-activeline-background {background: rgba(255,255,255,0.1) !important;}
+.cm-s-dracula .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
\ No newline at end of file
diff --git a/src/main/resources/codemirror/theme/eclipse.css b/src/main/resources/codemirror/theme/eclipse.css
new file mode 100755
index 0000000..317218e
--- /dev/null
+++ b/src/main/resources/codemirror/theme/eclipse.css
@@ -0,0 +1,23 @@
+.cm-s-eclipse span.cm-meta {color: #FF1717;}
+.cm-s-eclipse span.cm-keyword { line-height: 1em; font-weight: bold; color: #7F0055; }
+.cm-s-eclipse span.cm-atom {color: #219;}
+.cm-s-eclipse span.cm-number {color: #164;}
+.cm-s-eclipse span.cm-def {color: #00f;}
+.cm-s-eclipse span.cm-variable {color: black;}
+.cm-s-eclipse span.cm-variable-2 {color: #0000C0;}
+.cm-s-eclipse span.cm-variable-3 {color: #0000C0;}
+.cm-s-eclipse span.cm-property {color: black;}
+.cm-s-eclipse span.cm-operator {color: black;}
+.cm-s-eclipse span.cm-comment {color: #3F7F5F;}
+.cm-s-eclipse span.cm-string {color: #2A00FF;}
+.cm-s-eclipse span.cm-string-2 {color: #f50;}
+.cm-s-eclipse span.cm-qualifier {color: #555;}
+.cm-s-eclipse span.cm-builtin {color: #30a;}
+.cm-s-eclipse span.cm-bracket {color: #cc7;}
+.cm-s-eclipse span.cm-tag {color: #170;}
+.cm-s-eclipse span.cm-attribute {color: #00c;}
+.cm-s-eclipse span.cm-link {color: #219;}
+.cm-s-eclipse span.cm-error {color: #f00;}
+
+.cm-s-eclipse .CodeMirror-activeline-background {background: #e8f2ff !important;}
+.cm-s-eclipse .CodeMirror-matchingbracket {outline:1px solid grey; color:black !important;}
diff --git a/src/main/resources/codemirror/theme/elegant.css b/src/main/resources/codemirror/theme/elegant.css
new file mode 100755
index 0000000..dd7df7b
--- /dev/null
+++ b/src/main/resources/codemirror/theme/elegant.css
@@ -0,0 +1,13 @@
+.cm-s-elegant span.cm-number, .cm-s-elegant span.cm-string, .cm-s-elegant span.cm-atom {color: #762;}
+.cm-s-elegant span.cm-comment {color: #262; font-style: italic; line-height: 1em;}
+.cm-s-elegant span.cm-meta {color: #555; font-style: italic; line-height: 1em;}
+.cm-s-elegant span.cm-variable {color: black;}
+.cm-s-elegant span.cm-variable-2 {color: #b11;}
+.cm-s-elegant span.cm-qualifier {color: #555;}
+.cm-s-elegant span.cm-keyword {color: #730;}
+.cm-s-elegant span.cm-builtin {color: #30a;}
+.cm-s-elegant span.cm-link {color: #762;}
+.cm-s-elegant span.cm-error {background-color: #fdd;}
+
+.cm-s-elegant .CodeMirror-activeline-background {background: #e8f2ff !important;}
+.cm-s-elegant .CodeMirror-matchingbracket {outline:1px solid grey; color:black !important;}
diff --git a/src/main/resources/codemirror/theme/erlang-dark.css b/src/main/resources/codemirror/theme/erlang-dark.css
new file mode 100755
index 0000000..48552f8
--- /dev/null
+++ b/src/main/resources/codemirror/theme/erlang-dark.css
@@ -0,0 +1,34 @@
+.cm-s-erlang-dark.CodeMirror { background: #002240; color: white; }
+.cm-s-erlang-dark div.CodeMirror-selected { background: #b36539 !important; }
+.cm-s-erlang-dark .CodeMirror-line::selection, .cm-s-erlang-dark .CodeMirror-line > span::selection, .cm-s-erlang-dark .CodeMirror-line > span > span::selection { background: rgba(179, 101, 57, .99); }
+.cm-s-erlang-dark .CodeMirror-line::-moz-selection, .cm-s-erlang-dark .CodeMirror-line > span::-moz-selection, .cm-s-erlang-dark .CodeMirror-line > span > span::-moz-selection { background: rgba(179, 101, 57, .99); }
+.cm-s-erlang-dark .CodeMirror-gutters { background: #002240; border-right: 1px solid #aaa; }
+.cm-s-erlang-dark .CodeMirror-guttermarker { color: white; }
+.cm-s-erlang-dark .CodeMirror-guttermarker-subtle { color: #d0d0d0; }
+.cm-s-erlang-dark .CodeMirror-linenumber { color: #d0d0d0; }
+.cm-s-erlang-dark .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-erlang-dark span.cm-quote      { color: #ccc; }
+.cm-s-erlang-dark span.cm-atom       { color: #f133f1; }
+.cm-s-erlang-dark span.cm-attribute  { color: #ff80e1; }
+.cm-s-erlang-dark span.cm-bracket    { color: #ff9d00; }
+.cm-s-erlang-dark span.cm-builtin    { color: #eaa; }
+.cm-s-erlang-dark span.cm-comment    { color: #77f; }
+.cm-s-erlang-dark span.cm-def        { color: #e7a; }
+.cm-s-erlang-dark span.cm-keyword    { color: #ffee80; }
+.cm-s-erlang-dark span.cm-meta       { color: #50fefe; }
+.cm-s-erlang-dark span.cm-number     { color: #ffd0d0; }
+.cm-s-erlang-dark span.cm-operator   { color: #d55; }
+.cm-s-erlang-dark span.cm-property   { color: #ccc; }
+.cm-s-erlang-dark span.cm-qualifier  { color: #ccc; }
+.cm-s-erlang-dark span.cm-special    { color: #ffbbbb; }
+.cm-s-erlang-dark span.cm-string     { color: #3ad900; }
+.cm-s-erlang-dark span.cm-string-2   { color: #ccc; }
+.cm-s-erlang-dark span.cm-tag        { color: #9effff; }
+.cm-s-erlang-dark span.cm-variable   { color: #50fe50; }
+.cm-s-erlang-dark span.cm-variable-2 { color: #e0e; }
+.cm-s-erlang-dark span.cm-variable-3 { color: #ccc; }
+.cm-s-erlang-dark span.cm-error      { color: #9d1e15; }
+
+.cm-s-erlang-dark .CodeMirror-activeline-background {background: #013461 !important;}
+.cm-s-erlang-dark .CodeMirror-matchingbracket {outline:1px solid grey; color:white !important;}
diff --git a/src/main/resources/codemirror/theme/lesser-dark.css b/src/main/resources/codemirror/theme/lesser-dark.css
new file mode 100755
index 0000000..0573c06
--- /dev/null
+++ b/src/main/resources/codemirror/theme/lesser-dark.css
@@ -0,0 +1,47 @@
+/*
+http://lesscss.org/ dark theme
+Ported to CodeMirror by Peter Kroon
+*/
+.cm-s-lesser-dark {
+  line-height: 1.3em;
+}
+.cm-s-lesser-dark.CodeMirror { background: #262626; color: #EBEFE7; text-shadow: 0 -1px 1px #262626; }
+.cm-s-lesser-dark div.CodeMirror-selected {background: #45443B !important;} /* 33322B*/
+.cm-s-lesser-dark .CodeMirror-line::selection, .cm-s-lesser-dark .CodeMirror-line > span::selection, .cm-s-lesser-dark .CodeMirror-line > span > span::selection { background: rgba(69, 68, 59, .99); }
+.cm-s-lesser-dark .CodeMirror-line::-moz-selection, .cm-s-lesser-dark .CodeMirror-line > span::-moz-selection, .cm-s-lesser-dark .CodeMirror-line > span > span::-moz-selection { background: rgba(69, 68, 59, .99); }
+.cm-s-lesser-dark .CodeMirror-cursor { border-left: 1px solid white !important; }
+.cm-s-lesser-dark pre { padding: 0 8px; }/*editable code holder*/
+
+.cm-s-lesser-dark.CodeMirror span.CodeMirror-matchingbracket { color: #7EFC7E; }/*65FC65*/
+
+.cm-s-lesser-dark .CodeMirror-gutters { background: #262626; border-right:1px solid #aaa; }
+.cm-s-lesser-dark .CodeMirror-guttermarker { color: #599eff; }
+.cm-s-lesser-dark .CodeMirror-guttermarker-subtle { color: #777; }
+.cm-s-lesser-dark .CodeMirror-linenumber { color: #777; }
+
+.cm-s-lesser-dark span.cm-header {color: #a0a;}
+.cm-s-lesser-dark span.cm-quote {color: #090;}
+.cm-s-lesser-dark span.cm-keyword { color: #599eff; }
+.cm-s-lesser-dark span.cm-atom { color: #C2B470; }
+.cm-s-lesser-dark span.cm-number { color: #B35E4D; }
+.cm-s-lesser-dark span.cm-def {color: white;}
+.cm-s-lesser-dark span.cm-variable { color:#D9BF8C; }
+.cm-s-lesser-dark span.cm-variable-2 { color: #669199; }
+.cm-s-lesser-dark span.cm-variable-3 { color: white; }
+.cm-s-lesser-dark span.cm-property {color: #92A75C;}
+.cm-s-lesser-dark span.cm-operator {color: #92A75C;}
+.cm-s-lesser-dark span.cm-comment { color: #666; }
+.cm-s-lesser-dark span.cm-string { color: #BCD279; }
+.cm-s-lesser-dark span.cm-string-2 {color: #f50;}
+.cm-s-lesser-dark span.cm-meta { color: #738C73; }
+.cm-s-lesser-dark span.cm-qualifier {color: #555;}
+.cm-s-lesser-dark span.cm-builtin { color: #ff9e59; }
+.cm-s-lesser-dark span.cm-bracket { color: #EBEFE7; }
+.cm-s-lesser-dark span.cm-tag { color: #669199; }
+.cm-s-lesser-dark span.cm-attribute {color: #00c;}
+.cm-s-lesser-dark span.cm-hr {color: #999;}
+.cm-s-lesser-dark span.cm-link {color: #00c;}
+.cm-s-lesser-dark span.cm-error { color: #9d1e15; }
+
+.cm-s-lesser-dark .CodeMirror-activeline-background {background: #3C3A3A !important;}
+.cm-s-lesser-dark .CodeMirror-matchingbracket {outline:1px solid grey; color:white !important;}
diff --git a/src/main/resources/codemirror/theme/liquibyte.css b/src/main/resources/codemirror/theme/liquibyte.css
new file mode 100755
index 0000000..a6e070c
--- /dev/null
+++ b/src/main/resources/codemirror/theme/liquibyte.css
@@ -0,0 +1,95 @@
+.cm-s-liquibyte.CodeMirror {
+	background-color: #000;
+	color: #fff;
+	line-height: 1.2em;
+	font-size: 1em;
+}
+.CodeMirror-focused .cm-matchhighlight {
+	text-decoration: underline;
+	text-decoration-color: #0f0;
+	text-decoration-style: wavy;
+}
+.cm-trailingspace {
+	text-decoration: line-through;
+	text-decoration-color: #f00;
+	text-decoration-style: dotted;
+}
+.cm-tab {
+	text-decoration: line-through;
+	text-decoration-color: #404040;
+	text-decoration-style: dotted;
+}
+.cm-s-liquibyte .CodeMirror-gutters { background-color: #262626; border-right: 1px solid #505050; padding-right: 0.8em; }
+.cm-s-liquibyte .CodeMirror-gutter-elt div{ font-size: 1.2em; }
+.cm-s-liquibyte .CodeMirror-guttermarker {  }
+.cm-s-liquibyte .CodeMirror-guttermarker-subtle {  }
+.cm-s-liquibyte .CodeMirror-linenumber { color: #606060; padding-left: 0;}
+.cm-s-liquibyte .CodeMirror-cursor { border-left: 1px solid #eee !important; }
+
+.cm-s-liquibyte span.cm-comment     { color: #008000; }
+.cm-s-liquibyte span.cm-def         { color: #ffaf40; font-weight: bold; }
+.cm-s-liquibyte span.cm-keyword     { color: #c080ff; font-weight: bold; }
+.cm-s-liquibyte span.cm-builtin     { color: #ffaf40; font-weight: bold; }
+.cm-s-liquibyte span.cm-variable    { color: #5967ff; font-weight: bold; }
+.cm-s-liquibyte span.cm-string      { color: #ff8000; }
+.cm-s-liquibyte span.cm-number      { color: #0f0; font-weight: bold; }
+.cm-s-liquibyte span.cm-atom        { color: #bf3030; font-weight: bold; }
+
+.cm-s-liquibyte span.cm-variable-2  { color: #007f7f; font-weight: bold; }
+.cm-s-liquibyte span.cm-variable-3  { color: #c080ff; font-weight: bold; }
+.cm-s-liquibyte span.cm-property    { color: #999; font-weight: bold; }
+.cm-s-liquibyte span.cm-operator    { color: #fff; }
+
+.cm-s-liquibyte span.cm-meta        { color: #0f0; }
+.cm-s-liquibyte span.cm-qualifier   { color: #fff700; font-weight: bold; }
+.cm-s-liquibyte span.cm-bracket     { color: #cc7; }
+.cm-s-liquibyte span.cm-tag         { color: #ff0; font-weight: bold; }
+.cm-s-liquibyte span.cm-attribute   { color: #c080ff; font-weight: bold; }
+.cm-s-liquibyte span.cm-error       { color: #f00; }
+
+.cm-s-liquibyte .CodeMirror-selected { background-color: rgba(255, 0, 0, 0.25) !important; }
+
+.cm-s-liquibyte span.cm-compilation { background-color: rgba(255, 255, 255, 0.12); }
+
+.cm-s-liquibyte .CodeMirror-activeline-background {background-color: rgba(0, 255, 0, 0.15) !important;}
+
+/* Default styles for common addons */
+div.CodeMirror span.CodeMirror-matchingbracket { color: #0f0; font-weight: bold; }
+div.CodeMirror span.CodeMirror-nonmatchingbracket { color: #f00; font-weight: bold; }
+.CodeMirror-matchingtag { background-color: rgba(150, 255, 0, .3); }
+/* Scrollbars */
+/* Simple */
+div.CodeMirror-simplescroll-horizontal div:hover, div.CodeMirror-simplescroll-vertical div:hover {
+	background-color: rgba(80, 80, 80, .7);
+}
+div.CodeMirror-simplescroll-horizontal div, div.CodeMirror-simplescroll-vertical div {
+	background-color: rgba(80, 80, 80, .3);
+	border: 1px solid #404040;
+	border-radius: 5px;
+}
+div.CodeMirror-simplescroll-vertical div {
+	border-top: 1px solid #404040;
+	border-bottom: 1px solid #404040;
+}
+div.CodeMirror-simplescroll-horizontal div {
+	border-left: 1px solid #404040;
+	border-right: 1px solid #404040;
+}
+div.CodeMirror-simplescroll-vertical {
+	background-color: #262626;
+}
+div.CodeMirror-simplescroll-horizontal {
+	background-color: #262626;
+	border-top: 1px solid #404040;
+}
+/* Overlay */
+div.CodeMirror-overlayscroll-horizontal div, div.CodeMirror-overlayscroll-vertical div {
+	background-color: #404040;
+	border-radius: 5px;
+}
+div.CodeMirror-overlayscroll-vertical div {
+	border: 1px solid #404040;
+}
+div.CodeMirror-overlayscroll-horizontal div {
+	border: 1px solid #404040;
+}
diff --git a/src/main/resources/codemirror/theme/material.css b/src/main/resources/codemirror/theme/material.css
new file mode 100755
index 0000000..85e1f18
--- /dev/null
+++ b/src/main/resources/codemirror/theme/material.css
@@ -0,0 +1,105 @@
+/*
+
+    Name:       material
+    Author:     Michael Kaminsky (http://github.com/mkaminsky11)
+
+    Original material color scheme by Mattia Astorino (https://github.com/equinusocio/material-theme)
+
+*/
+
+.cm-s-material {
+  background-color: #263238;
+  color: rgba(233, 237, 237, 1);
+}
+.cm-s-material .CodeMirror-gutters {
+  background: #263238;
+  color: rgb(83,127,126);
+  border: none;
+}
+.cm-s-material .CodeMirror-guttermarker, .cm-s-material .CodeMirror-guttermarker-subtle, .cm-s-material .CodeMirror-linenumber {
+  color: rgb(83,127,126);
+}
+.cm-s-material .CodeMirror-cursor {
+  border-left: 1px solid #f8f8f0 !important;
+}
+.cm-s-material .CodeMirror-selected {
+  background: rgba(255, 255, 255, 0.15);
+}
+.cm-s-material.CodeMirror-focused .CodeMirror-selected {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-material .CodeMirror-line::selection, .cm-s-material .CodeMirror-line > span::selection, .cm-s-material .CodeMirror-line > span > span::selection {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-material .CodeMirror-line::-moz-selection, .cm-s-material .CodeMirror-line > span::-moz-selection, .cm-s-material .CodeMirror-line > span > span::-moz-selection {
+  background: rgba(255, 255, 255, 0.10);
+}
+
+.CodeMirror-activeline-background {
+  background: rgba(0, 0, 0, 0) !important;
+}
+.cm-s-material span.cm-keyword {
+  color: rgba(199, 146, 234, 1);
+}
+.cm-s-material span.cm-operator {
+  color: rgba(233, 237, 237, 1);
+}
+.cm-s-material span.cm-variable-2 {
+  color: #80CBC4;
+}
+.cm-s-material span.cm-variable-3 {
+  color: #82B1FF;
+}
+.cm-s-material span.cm-builtin {
+  color: #DECB6B;
+}
+.cm-s-material span.cm-atom {
+  color: #F77669;
+}
+.cm-s-material span.cm-number {
+  color: #F77669;
+}
+.cm-s-material span.cm-def {
+  color: rgba(233, 237, 237, 1);
+}
+.cm-s-material span.cm-error {
+  color: rgba(255, 255, 255, 1.0);
+  background-color: #EC5F67;
+}
+.cm-s-material span.cm-string {
+  color: #C3E88D;
+}
+.cm-s-material span.cm-string-2 {
+  color: #80CBC4;
+}
+.cm-s-material span.cm-comment {
+  color: #546E7A;
+}
+.cm-s-material span.cm-variable {
+  color: #82B1FF;
+}
+.cm-s-material span.cm-tag {
+  color: #80CBC4;
+}
+.cm-s-material span.cm-meta{
+  color: #80CBC4;
+}
+.cm-s-material span.cm-attribute {
+  color: #FFCB6B;
+}
+.cm-s-material span.cm-property {
+  color: #80CBAE;
+}
+.cm-s-material span.cm-qualifier {
+  color: #DECB6B;
+}
+.cm-s-material span.cm-variable-3{
+  color: #DECB6B;
+}
+.cm-s-material span.cm-tag {
+  color: rgba(255, 83, 112, 1);
+}
+.cm-s-material .CodeMirror-matchingbracket {
+  text-decoration: underline;
+  color: white !important;
+}
\ No newline at end of file
diff --git a/src/main/resources/codemirror/theme/mbo.css b/src/main/resources/codemirror/theme/mbo.css
new file mode 100755
index 0000000..cc9032e
--- /dev/null
+++ b/src/main/resources/codemirror/theme/mbo.css
@@ -0,0 +1,37 @@
+/****************************************************************/
+/*   Based on mbonaci's Brackets mbo theme                      */
+/*   https://github.com/mbonaci/global/blob/master/Mbo.tmTheme  */
+/*   Create your own: http://tmtheme-editor.herokuapp.com       */
+/****************************************************************/
+
+.cm-s-mbo.CodeMirror {background: #2c2c2c; color: #ffffec;}
+.cm-s-mbo div.CodeMirror-selected {background: #716C62 !important;}
+.cm-s-mbo .CodeMirror-line::selection, .cm-s-mbo .CodeMirror-line > span::selection, .cm-s-mbo .CodeMirror-line > span > span::selection { background: rgba(113, 108, 98, .99); }
+.cm-s-mbo .CodeMirror-line::-moz-selection, .cm-s-mbo .CodeMirror-line > span::-moz-selection, .cm-s-mbo .CodeMirror-line > span > span::-moz-selection { background: rgba(113, 108, 98, .99); }
+.cm-s-mbo .CodeMirror-gutters {background: #4e4e4e; border-right: 0px;}
+.cm-s-mbo .CodeMirror-guttermarker { color: white; }
+.cm-s-mbo .CodeMirror-guttermarker-subtle { color: grey; }
+.cm-s-mbo .CodeMirror-linenumber {color: #dadada;}
+.cm-s-mbo .CodeMirror-cursor {border-left: 1px solid #ffffec !important;}
+
+.cm-s-mbo span.cm-comment {color: #95958a;}
+.cm-s-mbo span.cm-atom {color: #00a8c6;}
+.cm-s-mbo span.cm-number {color: #00a8c6;}
+
+.cm-s-mbo span.cm-property, .cm-s-mbo span.cm-attribute {color: #9ddfe9;}
+.cm-s-mbo span.cm-keyword {color: #ffb928;}
+.cm-s-mbo span.cm-string {color: #ffcf6c;}
+.cm-s-mbo span.cm-string.cm-property {color: #ffffec;}
+
+.cm-s-mbo span.cm-variable {color: #ffffec;}
+.cm-s-mbo span.cm-variable-2 {color: #00a8c6;}
+.cm-s-mbo span.cm-def {color: #ffffec;}
+.cm-s-mbo span.cm-bracket {color: #fffffc; font-weight: bold;}
+.cm-s-mbo span.cm-tag {color: #9ddfe9;}
+.cm-s-mbo span.cm-link {color: #f54b07;}
+.cm-s-mbo span.cm-error {border-bottom: #636363; color: #ffffec;}
+.cm-s-mbo span.cm-qualifier {color: #ffffec;}
+
+.cm-s-mbo .CodeMirror-activeline-background {background: #494b41 !important;}
+.cm-s-mbo .CodeMirror-matchingbracket {color: #222 !important;}
+.cm-s-mbo .CodeMirror-matchingtag {background: rgba(255, 255, 255, .37);}
diff --git a/src/main/resources/codemirror/theme/mdn-like.css b/src/main/resources/codemirror/theme/mdn-like.css
new file mode 100755
index 0000000..771d447
--- /dev/null
+++ b/src/main/resources/codemirror/theme/mdn-like.css
@@ -0,0 +1,46 @@
+/*
+  MDN-LIKE Theme - Mozilla
+  Ported to CodeMirror by Peter Kroon <plakroon@gmail.com>
+  Report bugs/issues here: https://github.com/codemirror/CodeMirror/issues
+  GitHub: @peterkroon
+
+  The mdn-like theme is inspired on the displayed code examples at: https://developer.mozilla.org/en-US/docs/Web/CSS/animation
+
+*/
+.cm-s-mdn-like.CodeMirror { color: #999; background-color: #fff; }
+.cm-s-mdn-like .CodeMirror-selected { background: #cfc !important; }
+.cm-s-mdn-like .CodeMirror-line::selection, .cm-s-mdn-like .CodeMirror-line > span::selection, .cm-s-mdn-like .CodeMirror-line > span > span::selection { background: #cfc; }
+.cm-s-mdn-like .CodeMirror-line::-moz-selection, .cm-s-mdn-like .CodeMirror-line > span::-moz-selection, .cm-s-mdn-like .CodeMirror-line > span > span::-moz-selection { background: #cfc; }
+
+.cm-s-mdn-like .CodeMirror-gutters { background: #f8f8f8; border-left: 6px solid rgba(0,83,159,0.65); color: #333; }
+.cm-s-mdn-like .CodeMirror-linenumber { color: #aaa; padding-left: 8px; }
+div.cm-s-mdn-like .CodeMirror-cursor { border-left: 2px solid #222; }
+
+.cm-s-mdn-like .cm-keyword {  color: #6262FF; }
+.cm-s-mdn-like .cm-atom { color: #F90; }
+.cm-s-mdn-like .cm-number { color:  #ca7841; }
+.cm-s-mdn-like .cm-def { color: #8DA6CE; }
+.cm-s-mdn-like span.cm-variable-2, .cm-s-mdn-like span.cm-tag { color: #690; }
+.cm-s-mdn-like span.cm-variable-3, .cm-s-mdn-like span.cm-def { color: #07a; }
+
+.cm-s-mdn-like .cm-variable { color: #07a; }
+.cm-s-mdn-like .cm-property { color: #905; }
+.cm-s-mdn-like .cm-qualifier { color: #690; }
+
+.cm-s-mdn-like .cm-operator { color: #cda869; }
+.cm-s-mdn-like .cm-comment { color:#777; font-weight:normal; }
+.cm-s-mdn-like .cm-string { color:#07a; font-style:italic; }
+.cm-s-mdn-like .cm-string-2 { color:#bd6b18; } /*?*/
+.cm-s-mdn-like .cm-meta { color: #000; } /*?*/
+.cm-s-mdn-like .cm-builtin { color: #9B7536; } /*?*/
+.cm-s-mdn-like .cm-tag { color: #997643; }
+.cm-s-mdn-like .cm-attribute { color: #d6bb6d; } /*?*/
+.cm-s-mdn-like .cm-header { color: #FF6400; }
+.cm-s-mdn-like .cm-hr { color: #AEAEAE; }
+.cm-s-mdn-like .cm-link {   color:#ad9361; font-style:italic; text-decoration:none; }
+.cm-s-mdn-like .cm-error { border-bottom: 1px solid red; }
+
+div.cm-s-mdn-like .CodeMirror-activeline-background {background: #efefff;}
+div.cm-s-mdn-like span.CodeMirror-matchingbracket {outline:1px solid grey; color: inherit;}
+
+.cm-s-mdn-like.CodeMirror { background-image: url(data:image/png;base64,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); }
diff --git a/src/main/resources/codemirror/theme/midnight.css b/src/main/resources/codemirror/theme/midnight.css
new file mode 100755
index 0000000..9e9825b
--- /dev/null
+++ b/src/main/resources/codemirror/theme/midnight.css
@@ -0,0 +1,47 @@
+/* Based on the theme at http://bonsaiden.github.com/JavaScript-Garden */
+
+/*<!--match-->*/
+.cm-s-midnight span.CodeMirror-matchhighlight { background: #494949; }
+.cm-s-midnight.CodeMirror-focused span.CodeMirror-matchhighlight { background: #314D67 !important; }
+
+/*<!--activeline-->*/
+.cm-s-midnight .CodeMirror-activeline-background {background: #253540 !important;}
+
+.cm-s-midnight.CodeMirror {
+    background: #0F192A;
+    color: #D1EDFF;
+}
+
+.cm-s-midnight.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}
+
+.cm-s-midnight div.CodeMirror-selected {background: #314D67 !important;}
+.cm-s-midnight .CodeMirror-line::selection, .cm-s-midnight .CodeMirror-line > span::selection, .cm-s-midnight .CodeMirror-line > span > span::selection { background: rgba(49, 77, 103, .99); }
+.cm-s-midnight .CodeMirror-line::-moz-selection, .cm-s-midnight .CodeMirror-line > span::-moz-selection, .cm-s-midnight .CodeMirror-line > span > span::-moz-selection { background: rgba(49, 77, 103, .99); }
+.cm-s-midnight .CodeMirror-gutters {background: #0F192A; border-right: 1px solid;}
+.cm-s-midnight .CodeMirror-guttermarker { color: white; }
+.cm-s-midnight .CodeMirror-guttermarker-subtle { color: #d0d0d0; }
+.cm-s-midnight .CodeMirror-linenumber {color: #D0D0D0;}
+.cm-s-midnight .CodeMirror-cursor {
+    border-left: 1px solid #F8F8F0 !important;
+}
+
+.cm-s-midnight span.cm-comment {color: #428BDD;}
+.cm-s-midnight span.cm-atom {color: #AE81FF;}
+.cm-s-midnight span.cm-number {color: #D1EDFF;}
+
+.cm-s-midnight span.cm-property, .cm-s-midnight span.cm-attribute {color: #A6E22E;}
+.cm-s-midnight span.cm-keyword {color: #E83737;}
+.cm-s-midnight span.cm-string {color: #1DC116;}
+
+.cm-s-midnight span.cm-variable {color: #FFAA3E;}
+.cm-s-midnight span.cm-variable-2 {color: #FFAA3E;}
+.cm-s-midnight span.cm-def {color: #4DD;}
+.cm-s-midnight span.cm-bracket {color: #D1EDFF;}
+.cm-s-midnight span.cm-tag {color: #449;}
+.cm-s-midnight span.cm-link {color: #AE81FF;}
+.cm-s-midnight span.cm-error {background: #F92672; color: #F8F8F0;}
+
+.cm-s-midnight .CodeMirror-matchingbracket {
+  text-decoration: underline;
+  color: white !important;
+}
diff --git a/src/main/resources/codemirror/theme/monokai.css b/src/main/resources/codemirror/theme/monokai.css
new file mode 100755
index 0000000..e11e80c
--- /dev/null
+++ b/src/main/resources/codemirror/theme/monokai.css
@@ -0,0 +1,35 @@
+/* Based on Sublime Text's Monokai theme */
+
+.cm-s-monokai.CodeMirror {background: #272822; color: #f8f8f2;}
+.cm-s-monokai div.CodeMirror-selected {background: #49483E !important;}
+.cm-s-monokai .CodeMirror-line::selection, .cm-s-monokai .CodeMirror-line > span::selection, .cm-s-monokai .CodeMirror-line > span > span::selection { background: rgba(73, 72, 62, .99); }
+.cm-s-monokai .CodeMirror-line::-moz-selection, .cm-s-monokai .CodeMirror-line > span::-moz-selection, .cm-s-monokai .CodeMirror-line > span > span::-moz-selection { background: rgba(73, 72, 62, .99); }
+.cm-s-monokai .CodeMirror-gutters {background: #272822; border-right: 0px;}
+.cm-s-monokai .CodeMirror-guttermarker { color: white; }
+.cm-s-monokai .CodeMirror-guttermarker-subtle { color: #d0d0d0; }
+.cm-s-monokai .CodeMirror-linenumber {color: #d0d0d0;}
+.cm-s-monokai .CodeMirror-cursor {border-left: 1px solid #f8f8f0 !important;}
+
+.cm-s-monokai span.cm-comment {color: #75715e;}
+.cm-s-monokai span.cm-atom {color: #ae81ff;}
+.cm-s-monokai span.cm-number {color: #ae81ff;}
+
+.cm-s-monokai span.cm-property, .cm-s-monokai span.cm-attribute {color: #a6e22e;}
+.cm-s-monokai span.cm-keyword {color: #f92672;}
+.cm-s-monokai span.cm-string {color: #e6db74;}
+
+.cm-s-monokai span.cm-variable {color: #f8f8f2;}
+.cm-s-monokai span.cm-variable-2 {color: #9effff;}
+.cm-s-monokai span.cm-variable-3 {color: #66d9ef;}
+.cm-s-monokai span.cm-def {color: #fd971f;}
+.cm-s-monokai span.cm-bracket {color: #f8f8f2;}
+.cm-s-monokai span.cm-tag {color: #f92672;}
+.cm-s-monokai span.cm-header {color: #ae81ff;}
+.cm-s-monokai span.cm-link {color: #ae81ff;}
+.cm-s-monokai span.cm-error {background: #f92672; color: #f8f8f0;}
+
+.cm-s-monokai .CodeMirror-activeline-background {background: #373831 !important;}
+.cm-s-monokai .CodeMirror-matchingbracket {
+  text-decoration: underline;
+  color: white !important;
+}
diff --git a/src/main/resources/codemirror/theme/neat.css b/src/main/resources/codemirror/theme/neat.css
new file mode 100755
index 0000000..115083b
--- /dev/null
+++ b/src/main/resources/codemirror/theme/neat.css
@@ -0,0 +1,12 @@
+.cm-s-neat span.cm-comment { color: #a86; }
+.cm-s-neat span.cm-keyword { line-height: 1em; font-weight: bold; color: blue; }
+.cm-s-neat span.cm-string { color: #a22; }
+.cm-s-neat span.cm-builtin { line-height: 1em; font-weight: bold; color: #077; }
+.cm-s-neat span.cm-special { line-height: 1em; font-weight: bold; color: #0aa; }
+.cm-s-neat span.cm-variable { color: black; }
+.cm-s-neat span.cm-number, .cm-s-neat span.cm-atom { color: #3a3; }
+.cm-s-neat span.cm-meta {color: #555;}
+.cm-s-neat span.cm-link { color: #3a3; }
+
+.cm-s-neat .CodeMirror-activeline-background {background: #e8f2ff !important;}
+.cm-s-neat .CodeMirror-matchingbracket {outline:1px solid grey; color:black !important;}
diff --git a/src/main/resources/codemirror/theme/neo.css b/src/main/resources/codemirror/theme/neo.css
new file mode 100755
index 0000000..cecaaf2
--- /dev/null
+++ b/src/main/resources/codemirror/theme/neo.css
@@ -0,0 +1,43 @@
+/* neo theme for codemirror */
+
+/* Color scheme */
+
+.cm-s-neo.CodeMirror {
+  background-color:#ffffff;
+  color:#2e383c;
+  line-height:1.4375;
+}
+.cm-s-neo .cm-comment {color:#75787b}
+.cm-s-neo .cm-keyword, .cm-s-neo .cm-property {color:#1d75b3}
+.cm-s-neo .cm-atom,.cm-s-neo .cm-number {color:#75438a}
+.cm-s-neo .cm-node,.cm-s-neo .cm-tag {color:#9c3328}
+.cm-s-neo .cm-string {color:#b35e14}
+.cm-s-neo .cm-variable,.cm-s-neo .cm-qualifier {color:#047d65}
+
+
+/* Editor styling */
+
+.cm-s-neo pre {
+  padding:0;
+}
+
+.cm-s-neo .CodeMirror-gutters {
+  border:none;
+  border-right:10px solid transparent;
+  background-color:transparent;
+}
+
+.cm-s-neo .CodeMirror-linenumber {
+  padding:0;
+  color:#e0e2e5;
+}
+
+.cm-s-neo .CodeMirror-guttermarker { color: #1d75b3; }
+.cm-s-neo .CodeMirror-guttermarker-subtle { color: #e0e2e5; }
+
+.cm-s-neo div.CodeMirror-cursor {
+  width: auto;
+  border: 0;
+  background: rgba(155,157,162,0.37);
+  z-index: 1;
+}
diff --git a/src/main/resources/codemirror/theme/night.css b/src/main/resources/codemirror/theme/night.css
new file mode 100755
index 0000000..6fbbcaa
--- /dev/null
+++ b/src/main/resources/codemirror/theme/night.css
@@ -0,0 +1,28 @@
+/* Loosely based on the Midnight Textmate theme */
+
+.cm-s-night.CodeMirror { background: #0a001f; color: #f8f8f8; }
+.cm-s-night div.CodeMirror-selected { background: #447 !important; }
+.cm-s-night .CodeMirror-line::selection, .cm-s-night .CodeMirror-line > span::selection, .cm-s-night .CodeMirror-line > span > span::selection { background: rgba(68, 68, 119, .99); }
+.cm-s-night .CodeMirror-line::-moz-selection, .cm-s-night .CodeMirror-line > span::-moz-selection, .cm-s-night .CodeMirror-line > span > span::-moz-selection { background: rgba(68, 68, 119, .99); }
+.cm-s-night .CodeMirror-gutters { background: #0a001f; border-right: 1px solid #aaa; }
+.cm-s-night .CodeMirror-guttermarker { color: white; }
+.cm-s-night .CodeMirror-guttermarker-subtle { color: #bbb; }
+.cm-s-night .CodeMirror-linenumber { color: #f8f8f8; }
+.cm-s-night .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-night span.cm-comment { color: #6900a1; }
+.cm-s-night span.cm-atom { color: #845dc4; }
+.cm-s-night span.cm-number, .cm-s-night span.cm-attribute { color: #ffd500; }
+.cm-s-night span.cm-keyword { color: #599eff; }
+.cm-s-night span.cm-string { color: #37f14a; }
+.cm-s-night span.cm-meta { color: #7678e2; }
+.cm-s-night span.cm-variable-2, .cm-s-night span.cm-tag { color: #99b2ff; }
+.cm-s-night span.cm-variable-3, .cm-s-night span.cm-def { color: white; }
+.cm-s-night span.cm-bracket { color: #8da6ce; }
+.cm-s-night span.cm-comment { color: #6900a1; }
+.cm-s-night span.cm-builtin, .cm-s-night span.cm-special { color: #ff9e59; }
+.cm-s-night span.cm-link { color: #845dc4; }
+.cm-s-night span.cm-error { color: #9d1e15; }
+
+.cm-s-night .CodeMirror-activeline-background {background: #1C005A !important;}
+.cm-s-night .CodeMirror-matchingbracket {outline:1px solid grey; color:white !important;}
diff --git a/src/main/resources/codemirror/theme/paraiso-dark.css b/src/main/resources/codemirror/theme/paraiso-dark.css
new file mode 100755
index 0000000..2b6a797
--- /dev/null
+++ b/src/main/resources/codemirror/theme/paraiso-dark.css
@@ -0,0 +1,38 @@
+/*
+
+    Name:       Paraíso (Dark)
+    Author:     Jan T. Sott
+
+    Color scheme by Jan T. Sott (https://github.com/idleberg/Paraiso-CodeMirror)
+    Inspired by the art of Rubens LP (http://www.rubenslp.com.br)
+
+*/
+
+.cm-s-paraiso-dark.CodeMirror {background: #2f1e2e; color: #b9b6b0;}
+.cm-s-paraiso-dark div.CodeMirror-selected {background: #41323f !important;}
+.cm-s-paraiso-dark .CodeMirror-line::selection, .cm-s-paraiso-dark .CodeMirror-line > span::selection, .cm-s-paraiso-dark .CodeMirror-line > span > span::selection { background: rgba(65, 50, 63, .99); }
+.cm-s-paraiso-dark .CodeMirror-line::-moz-selection, .cm-s-paraiso-dark .CodeMirror-line > span::-moz-selection, .cm-s-paraiso-dark .CodeMirror-line > span > span::-moz-selection { background: rgba(65, 50, 63, .99); }
+.cm-s-paraiso-dark .CodeMirror-gutters {background: #2f1e2e; border-right: 0px;}
+.cm-s-paraiso-dark .CodeMirror-guttermarker { color: #ef6155; }
+.cm-s-paraiso-dark .CodeMirror-guttermarker-subtle { color: #776e71; }
+.cm-s-paraiso-dark .CodeMirror-linenumber {color: #776e71;}
+.cm-s-paraiso-dark .CodeMirror-cursor {border-left: 1px solid #8d8687 !important;}
+
+.cm-s-paraiso-dark span.cm-comment {color: #e96ba8;}
+.cm-s-paraiso-dark span.cm-atom {color: #815ba4;}
+.cm-s-paraiso-dark span.cm-number {color: #815ba4;}
+
+.cm-s-paraiso-dark span.cm-property, .cm-s-paraiso-dark span.cm-attribute {color: #48b685;}
+.cm-s-paraiso-dark span.cm-keyword {color: #ef6155;}
+.cm-s-paraiso-dark span.cm-string {color: #fec418;}
+
+.cm-s-paraiso-dark span.cm-variable {color: #48b685;}
+.cm-s-paraiso-dark span.cm-variable-2 {color: #06b6ef;}
+.cm-s-paraiso-dark span.cm-def {color: #f99b15;}
+.cm-s-paraiso-dark span.cm-bracket {color: #b9b6b0;}
+.cm-s-paraiso-dark span.cm-tag {color: #ef6155;}
+.cm-s-paraiso-dark span.cm-link {color: #815ba4;}
+.cm-s-paraiso-dark span.cm-error {background: #ef6155; color: #8d8687;}
+
+.cm-s-paraiso-dark .CodeMirror-activeline-background {background: #4D344A !important;}
+.cm-s-paraiso-dark .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
diff --git a/src/main/resources/codemirror/theme/paraiso-light.css b/src/main/resources/codemirror/theme/paraiso-light.css
new file mode 100755
index 0000000..01d2e11
--- /dev/null
+++ b/src/main/resources/codemirror/theme/paraiso-light.css
@@ -0,0 +1,38 @@
+/*
+
+    Name:       Paraíso (Light)
+    Author:     Jan T. Sott
+
+    Color scheme by Jan T. Sott (https://github.com/idleberg/Paraiso-CodeMirror)
+    Inspired by the art of Rubens LP (http://www.rubenslp.com.br)
+
+*/
+
+.cm-s-paraiso-light.CodeMirror {background: #e7e9db; color: #41323f;}
+.cm-s-paraiso-light div.CodeMirror-selected {background: #b9b6b0 !important;}
+.cm-s-paraiso-light .CodeMirror-line::selection, .cm-s-paraiso-light .CodeMirror-line > span::selection, .cm-s-paraiso-light .CodeMirror-line > span > span::selection { background: #b9b6b0; }
+.cm-s-paraiso-light .CodeMirror-line::-moz-selection, .cm-s-paraiso-light .CodeMirror-line > span::-moz-selection, .cm-s-paraiso-light .CodeMirror-line > span > span::-moz-selection { background: #b9b6b0; }
+.cm-s-paraiso-light .CodeMirror-gutters {background: #e7e9db; border-right: 0px;}
+.cm-s-paraiso-light .CodeMirror-guttermarker { color: black; }
+.cm-s-paraiso-light .CodeMirror-guttermarker-subtle { color: #8d8687; }
+.cm-s-paraiso-light .CodeMirror-linenumber {color: #8d8687;}
+.cm-s-paraiso-light .CodeMirror-cursor {border-left: 1px solid #776e71 !important;}
+
+.cm-s-paraiso-light span.cm-comment {color: #e96ba8;}
+.cm-s-paraiso-light span.cm-atom {color: #815ba4;}
+.cm-s-paraiso-light span.cm-number {color: #815ba4;}
+
+.cm-s-paraiso-light span.cm-property, .cm-s-paraiso-light span.cm-attribute {color: #48b685;}
+.cm-s-paraiso-light span.cm-keyword {color: #ef6155;}
+.cm-s-paraiso-light span.cm-string {color: #fec418;}
+
+.cm-s-paraiso-light span.cm-variable {color: #48b685;}
+.cm-s-paraiso-light span.cm-variable-2 {color: #06b6ef;}
+.cm-s-paraiso-light span.cm-def {color: #f99b15;}
+.cm-s-paraiso-light span.cm-bracket {color: #41323f;}
+.cm-s-paraiso-light span.cm-tag {color: #ef6155;}
+.cm-s-paraiso-light span.cm-link {color: #815ba4;}
+.cm-s-paraiso-light span.cm-error {background: #ef6155; color: #776e71;}
+
+.cm-s-paraiso-light .CodeMirror-activeline-background {background: #CFD1C4 !important;}
+.cm-s-paraiso-light .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
diff --git a/src/main/resources/codemirror/theme/pastel-on-dark.css b/src/main/resources/codemirror/theme/pastel-on-dark.css
new file mode 100755
index 0000000..1c7f84c
--- /dev/null
+++ b/src/main/resources/codemirror/theme/pastel-on-dark.css
@@ -0,0 +1,53 @@
+/**
+ * Pastel On Dark theme ported from ACE editor
+ * @license MIT
+ * @copyright AtomicPages LLC 2014
+ * @author Dennis Thompson, AtomicPages LLC
+ * @version 1.1
+ * @source https://github.com/atomicpages/codemirror-pastel-on-dark-theme
+ */
+
+.cm-s-pastel-on-dark.CodeMirror {
+	background: #2c2827;
+	color: #8F938F;
+	line-height: 1.5;
+	font-size: 14px;
+}
+.cm-s-pastel-on-dark div.CodeMirror-selected { background: rgba(221,240,255,0.2) !important; }
+.cm-s-pastel-on-dark .CodeMirror-line::selection, .cm-s-pastel-on-dark .CodeMirror-line > span::selection, .cm-s-pastel-on-dark .CodeMirror-line > span > span::selection { background: rgba(221,240,255,0.2); }
+.cm-s-pastel-on-dark .CodeMirror-line::-moz-selection, .cm-s-pastel-on-dark .CodeMirror-line > span::-moz-selection, .cm-s-pastel-on-dark .CodeMirror-line > span > span::-moz-selection { background: rgba(221,240,255,0.2); }
+
+.cm-s-pastel-on-dark .CodeMirror-gutters {
+	background: #34302f;
+	border-right: 0px;
+	padding: 0 3px;
+}
+.cm-s-pastel-on-dark .CodeMirror-guttermarker { color: white; }
+.cm-s-pastel-on-dark .CodeMirror-guttermarker-subtle { color: #8F938F; }
+.cm-s-pastel-on-dark .CodeMirror-linenumber { color: #8F938F; }
+.cm-s-pastel-on-dark .CodeMirror-cursor { border-left: 1px solid #A7A7A7 !important; }
+.cm-s-pastel-on-dark span.cm-comment { color: #A6C6FF; }
+.cm-s-pastel-on-dark span.cm-atom { color: #DE8E30; }
+.cm-s-pastel-on-dark span.cm-number { color: #CCCCCC; }
+.cm-s-pastel-on-dark span.cm-property { color: #8F938F; }
+.cm-s-pastel-on-dark span.cm-attribute { color: #a6e22e; }
+.cm-s-pastel-on-dark span.cm-keyword { color: #AEB2F8; }
+.cm-s-pastel-on-dark span.cm-string { color: #66A968; }
+.cm-s-pastel-on-dark span.cm-variable { color: #AEB2F8; }
+.cm-s-pastel-on-dark span.cm-variable-2 { color: #BEBF55; }
+.cm-s-pastel-on-dark span.cm-variable-3 { color: #DE8E30; }
+.cm-s-pastel-on-dark span.cm-def { color: #757aD8; }
+.cm-s-pastel-on-dark span.cm-bracket { color: #f8f8f2; }
+.cm-s-pastel-on-dark span.cm-tag { color: #C1C144; }
+.cm-s-pastel-on-dark span.cm-link { color: #ae81ff; }
+.cm-s-pastel-on-dark span.cm-qualifier,.cm-s-pastel-on-dark span.cm-builtin { color: #C1C144; }
+.cm-s-pastel-on-dark span.cm-error {
+	background: #757aD8;
+	color: #f8f8f0;
+}
+.cm-s-pastel-on-dark .CodeMirror-activeline-background { background: rgba(255, 255, 255, 0.031) !important; }
+.cm-s-pastel-on-dark .CodeMirror-matchingbracket {
+	border: 1px solid rgba(255,255,255,0.25);
+	color: #8F938F !important;
+	margin: -1px -1px 0 -1px;
+}
diff --git a/src/main/resources/codemirror/theme/rubyblue.css b/src/main/resources/codemirror/theme/rubyblue.css
new file mode 100755
index 0000000..064f192
--- /dev/null
+++ b/src/main/resources/codemirror/theme/rubyblue.css
@@ -0,0 +1,25 @@
+.cm-s-rubyblue.CodeMirror { background: #112435; color: white; }
+.cm-s-rubyblue div.CodeMirror-selected { background: #38566F !important; }
+.cm-s-rubyblue .CodeMirror-line::selection, .cm-s-rubyblue .CodeMirror-line > span::selection, .cm-s-rubyblue .CodeMirror-line > span > span::selection { background: rgba(56, 86, 111, 0.99); }
+.cm-s-rubyblue .CodeMirror-line::-moz-selection, .cm-s-rubyblue .CodeMirror-line > span::-moz-selection, .cm-s-rubyblue .CodeMirror-line > span > span::-moz-selection { background: rgba(56, 86, 111, 0.99); }
+.cm-s-rubyblue .CodeMirror-gutters { background: #1F4661; border-right: 7px solid #3E7087; }
+.cm-s-rubyblue .CodeMirror-guttermarker { color: white; }
+.cm-s-rubyblue .CodeMirror-guttermarker-subtle { color: #3E7087; }
+.cm-s-rubyblue .CodeMirror-linenumber { color: white; }
+.cm-s-rubyblue .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-rubyblue span.cm-comment { color: #999; font-style:italic; line-height: 1em; }
+.cm-s-rubyblue span.cm-atom { color: #F4C20B; }
+.cm-s-rubyblue span.cm-number, .cm-s-rubyblue span.cm-attribute { color: #82C6E0; }
+.cm-s-rubyblue span.cm-keyword { color: #F0F; }
+.cm-s-rubyblue span.cm-string { color: #F08047; }
+.cm-s-rubyblue span.cm-meta { color: #F0F; }
+.cm-s-rubyblue span.cm-variable-2, .cm-s-rubyblue span.cm-tag { color: #7BD827; }
+.cm-s-rubyblue span.cm-variable-3, .cm-s-rubyblue span.cm-def { color: white; }
+.cm-s-rubyblue span.cm-bracket { color: #F0F; }
+.cm-s-rubyblue span.cm-link { color: #F4C20B; }
+.cm-s-rubyblue span.CodeMirror-matchingbracket { color:#F0F !important; }
+.cm-s-rubyblue span.cm-builtin, .cm-s-rubyblue span.cm-special { color: #FF9D00; }
+.cm-s-rubyblue span.cm-error { color: #AF2018; }
+
+.cm-s-rubyblue .CodeMirror-activeline-background {background: #173047 !important;}
diff --git a/src/main/resources/codemirror/theme/seti.css b/src/main/resources/codemirror/theme/seti.css
new file mode 100755
index 0000000..ea27d5e
--- /dev/null
+++ b/src/main/resources/codemirror/theme/seti.css
@@ -0,0 +1,88 @@
+/*
+
+    Name:       seti
+    Author:     Michael Kaminsky (http://github.com/mkaminsky11)
+
+    Original seti color scheme by Jesse Weed (https://github.com/jesseweed/seti-syntax)
+
+*/
+
+
+.cm-s-seti.CodeMirror {
+  background-color: #151718 !important;
+  color: #CFD2D1 !important;
+  border: none;
+}
+.cm-s-seti .CodeMirror-gutters{
+  color: #404b53;
+  background-color: #0E1112;
+  border: none;
+}
+.cm-s-seti .CodeMirror-cursor {
+  border-left: solid thin #f8f8f0 !important;
+}
+.cm-s-seti .CodeMirror-linenumber {
+  color: #6D8A88;
+}
+.cm-s-seti.CodeMirror-focused .CodeMirror-selected {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-seti .CodeMirror-line::selection, .cm-s-seti .CodeMirror-line > span::selection, .cm-s-seti .CodeMirror-line > span > span::selection {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-seti .CodeMirror-line::-moz-selection, .cm-s-seti .CodeMirror-line > span::-moz-selection, .cm-s-seti .CodeMirror-line > span > span::-moz-selection {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-seti span.cm-comment {
+  color: #41535b;
+}
+.cm-s-seti span.cm-string, .cm-s-seti span.cm-string-2 {
+  color: #55b5db;
+}
+.cm-s-seti span.cm-number {
+  color: #cd3f45;
+}
+.cm-s-seti span.cm-variable {
+  color: #55b5db;
+}
+.cm-s-seti span.cm-variable-2 {
+  color: #a074c4;
+}
+.cm-s-seti span.cm-def {
+  color: #55b5db;
+}
+.cm-s-seti span.cm-keyword {
+  color: #ff79c6;
+}
+.cm-s-seti span.cm-operator {
+  color: #9fca56;
+}
+.cm-s-seti span.cm-keyword {
+  color: #e6cd69;
+}
+.cm-s-seti span.cm-atom {
+  color: #cd3f45;
+}
+.cm-s-seti span.cm-meta {
+  color: #55b5db;
+}
+.cm-s-seti span.cm-tag {
+  color: #55b5db;
+}
+.cm-s-seti span.cm-attribute {
+  color: #9fca56;
+}
+.cm-s-seti span.cm-qualifier {
+  color: #9fca56;
+}
+.cm-s-seti span.cm-property {
+  color: #a074c4;
+}
+.cm-s-seti span.cm-variable-3 {
+  color: #9fca56;
+}
+.cm-s-seti span.cm-builtin {
+  color: #9fca56;
+}
+.cm-s-seti .CodeMirror-activeline-background {background: #101213 !important;}
+.cm-s-seti .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
\ No newline at end of file
diff --git a/src/main/resources/codemirror/theme/solarized.css b/src/main/resources/codemirror/theme/solarized.css
new file mode 100755
index 0000000..18ed6de
--- /dev/null
+++ b/src/main/resources/codemirror/theme/solarized.css
@@ -0,0 +1,165 @@
+/*
+Solarized theme for code-mirror
+http://ethanschoonover.com/solarized
+*/
+
+/*
+Solarized color pallet
+http://ethanschoonover.com/solarized/img/solarized-palette.png
+*/
+
+.solarized.base03 { color: #002b36; }
+.solarized.base02 { color: #073642; }
+.solarized.base01 { color: #586e75; }
+.solarized.base00 { color: #657b83; }
+.solarized.base0 { color: #839496; }
+.solarized.base1 { color: #93a1a1; }
+.solarized.base2 { color: #eee8d5; }
+.solarized.base3  { color: #fdf6e3; }
+.solarized.solar-yellow  { color: #b58900; }
+.solarized.solar-orange  { color: #cb4b16; }
+.solarized.solar-red { color: #dc322f; }
+.solarized.solar-magenta { color: #d33682; }
+.solarized.solar-violet  { color: #6c71c4; }
+.solarized.solar-blue { color: #268bd2; }
+.solarized.solar-cyan { color: #2aa198; }
+.solarized.solar-green { color: #859900; }
+
+/* Color scheme for code-mirror */
+
+.cm-s-solarized {
+  line-height: 1.45em;
+  color-profile: sRGB;
+  rendering-intent: auto;
+}
+.cm-s-solarized.cm-s-dark {
+  color: #839496;
+  background-color:  #002b36;
+  text-shadow: #002b36 0 1px;
+}
+.cm-s-solarized.cm-s-light {
+  background-color: #fdf6e3;
+  color: #657b83;
+  text-shadow: #eee8d5 0 1px;
+}
+
+.cm-s-solarized .CodeMirror-widget {
+  text-shadow: none;
+}
+
+.cm-s-solarized .cm-header { color: #586e75; }
+.cm-s-solarized .cm-quote { color: #93a1a1; }
+
+.cm-s-solarized .cm-keyword { color: #cb4b16 }
+.cm-s-solarized .cm-atom { color: #d33682; }
+.cm-s-solarized .cm-number { color: #d33682; }
+.cm-s-solarized .cm-def { color: #2aa198; }
+
+.cm-s-solarized .cm-variable { color: #839496; }
+.cm-s-solarized .cm-variable-2 { color: #b58900; }
+.cm-s-solarized .cm-variable-3 { color: #6c71c4; }
+
+.cm-s-solarized .cm-property { color: #2aa198; }
+.cm-s-solarized .cm-operator {color: #6c71c4;}
+
+.cm-s-solarized .cm-comment { color: #586e75; font-style:italic; }
+
+.cm-s-solarized .cm-string { color: #859900; }
+.cm-s-solarized .cm-string-2 { color: #b58900; }
+
+.cm-s-solarized .cm-meta { color: #859900; }
+.cm-s-solarized .cm-qualifier { color: #b58900; }
+.cm-s-solarized .cm-builtin { color: #d33682; }
+.cm-s-solarized .cm-bracket { color: #cb4b16; }
+.cm-s-solarized .CodeMirror-matchingbracket { color: #859900; }
+.cm-s-solarized .CodeMirror-nonmatchingbracket { color: #dc322f; }
+.cm-s-solarized .cm-tag { color: #93a1a1 }
+.cm-s-solarized .cm-attribute {  color: #2aa198; }
+.cm-s-solarized .cm-hr {
+  color: transparent;
+  border-top: 1px solid #586e75;
+  display: block;
+}
+.cm-s-solarized .cm-link { color: #93a1a1; cursor: pointer; }
+.cm-s-solarized .cm-special { color: #6c71c4; }
+.cm-s-solarized .cm-em {
+  color: #999;
+  text-decoration: underline;
+  text-decoration-style: dotted;
+}
+.cm-s-solarized .cm-strong { color: #eee; }
+.cm-s-solarized .cm-error,
+.cm-s-solarized .cm-invalidchar {
+  color: #586e75;
+  border-bottom: 1px dotted #dc322f;
+}
+
+.cm-s-solarized.cm-s-dark .CodeMirror-selected { background: #073642; }
+.cm-s-solarized.cm-s-dark.CodeMirror ::selection { background: rgba(7, 54, 66, 0.99); }
+.cm-s-solarized.cm-s-dark .CodeMirror-line::-moz-selection, .cm-s-dark .CodeMirror-line > span::-moz-selection, .cm-s-dark .CodeMirror-line > span > span::-moz-selection { background: rgba(7, 54, 66, 0.99); }
+
+.cm-s-solarized.cm-s-light .CodeMirror-selected { background: #eee8d5; }
+.cm-s-solarized.cm-s-light .CodeMirror-line::selection, .cm-s-light .CodeMirror-line > span::selection, .cm-s-light .CodeMirror-line > span > span::selection { background: #eee8d5; }
+.cm-s-solarized.cm-s-light .CodeMirror-line::-moz-selection, .cm-s-ligh .CodeMirror-line > span::-moz-selection, .cm-s-ligh .CodeMirror-line > span > span::-moz-selection { background: #eee8d5; }
+
+/* Editor styling */
+
+
+
+/* Little shadow on the view-port of the buffer view */
+.cm-s-solarized.CodeMirror {
+  -moz-box-shadow: inset 7px 0 12px -6px #000;
+  -webkit-box-shadow: inset 7px 0 12px -6px #000;
+  box-shadow: inset 7px 0 12px -6px #000;
+}
+
+/* Gutter border and some shadow from it  */
+.cm-s-solarized .CodeMirror-gutters {
+  border-right: 1px solid;
+}
+
+/* Gutter colors and line number styling based of color scheme (dark / light) */
+
+/* Dark */
+.cm-s-solarized.cm-s-dark .CodeMirror-gutters {
+  background-color:  #002b36;
+  border-color: #00232c;
+}
+
+.cm-s-solarized.cm-s-dark .CodeMirror-linenumber {
+  text-shadow: #021014 0 -1px;
+}
+
+/* Light */
+.cm-s-solarized.cm-s-light .CodeMirror-gutters {
+  background-color: #fdf6e3;
+  border-color: #eee8d5;
+}
+
+/* Common */
+.cm-s-solarized .CodeMirror-linenumber {
+  color: #586e75;
+  padding: 0 5px;
+}
+.cm-s-solarized .CodeMirror-guttermarker-subtle { color: #586e75; }
+.cm-s-solarized.cm-s-dark .CodeMirror-guttermarker { color: #ddd; }
+.cm-s-solarized.cm-s-light .CodeMirror-guttermarker { color: #cb4b16; }
+
+.cm-s-solarized .CodeMirror-gutter .CodeMirror-gutter-text {
+  color: #586e75;
+}
+
+.cm-s-solarized .CodeMirror-lines .CodeMirror-cursor {
+  border-left: 1px solid #819090;
+}
+
+/*
+Active line. Negative margin compensates left padding of the text in the
+view-port
+*/
+.cm-s-solarized.cm-s-dark .CodeMirror-activeline-background {
+  background: rgba(255, 255, 255, 0.10);
+}
+.cm-s-solarized.cm-s-light .CodeMirror-activeline-background {
+  background: rgba(0, 0, 0, 0.10);
+}
diff --git a/src/main/resources/codemirror/theme/the-matrix.css b/src/main/resources/codemirror/theme/the-matrix.css
new file mode 100755
index 0000000..ec6046a
--- /dev/null
+++ b/src/main/resources/codemirror/theme/the-matrix.css
@@ -0,0 +1,30 @@
+.cm-s-the-matrix.CodeMirror { background: #000000; color: #00FF00; }
+.cm-s-the-matrix div.CodeMirror-selected { background: #2D2D2D !important; }
+.cm-s-the-matrix .CodeMirror-line::selection, .cm-s-the-matrix .CodeMirror-line > span::selection, .cm-s-the-matrix .CodeMirror-line > span > span::selection { background: rgba(45, 45, 45, 0.99); }
+.cm-s-the-matrix .CodeMirror-line::-moz-selection, .cm-s-the-matrix .CodeMirror-line > span::-moz-selection, .cm-s-the-matrix .CodeMirror-line > span > span::-moz-selection { background: rgba(45, 45, 45, 0.99); }
+.cm-s-the-matrix .CodeMirror-gutters { background: #060; border-right: 2px solid #00FF00; }
+.cm-s-the-matrix .CodeMirror-guttermarker { color: #0f0; }
+.cm-s-the-matrix .CodeMirror-guttermarker-subtle { color: white; }
+.cm-s-the-matrix .CodeMirror-linenumber { color: #FFFFFF; }
+.cm-s-the-matrix .CodeMirror-cursor { border-left: 1px solid #00FF00 !important; }
+
+.cm-s-the-matrix span.cm-keyword {color: #008803; font-weight: bold;}
+.cm-s-the-matrix span.cm-atom {color: #3FF;}
+.cm-s-the-matrix span.cm-number {color: #FFB94F;}
+.cm-s-the-matrix span.cm-def {color: #99C;}
+.cm-s-the-matrix span.cm-variable {color: #F6C;}
+.cm-s-the-matrix span.cm-variable-2 {color: #C6F;}
+.cm-s-the-matrix span.cm-variable-3 {color: #96F;}
+.cm-s-the-matrix span.cm-property {color: #62FFA0;}
+.cm-s-the-matrix span.cm-operator {color: #999}
+.cm-s-the-matrix span.cm-comment {color: #CCCCCC;}
+.cm-s-the-matrix span.cm-string {color: #39C;}
+.cm-s-the-matrix span.cm-meta {color: #C9F;}
+.cm-s-the-matrix span.cm-qualifier {color: #FFF700;}
+.cm-s-the-matrix span.cm-builtin {color: #30a;}
+.cm-s-the-matrix span.cm-bracket {color: #cc7;}
+.cm-s-the-matrix span.cm-tag {color: #FFBD40;}
+.cm-s-the-matrix span.cm-attribute {color: #FFF700;}
+.cm-s-the-matrix span.cm-error {color: #FF0000;}
+
+.cm-s-the-matrix .CodeMirror-activeline-background {background: #040;}
diff --git a/src/main/resources/codemirror/theme/tomorrow-night-bright.css b/src/main/resources/codemirror/theme/tomorrow-night-bright.css
new file mode 100755
index 0000000..decb82d
--- /dev/null
+++ b/src/main/resources/codemirror/theme/tomorrow-night-bright.css
@@ -0,0 +1,35 @@
+/*
+
+    Name:       Tomorrow Night - Bright
+    Author:     Chris Kempson
+
+    Port done by Gerard Braad <me@gbraad.nl>
+
+*/
+
+.cm-s-tomorrow-night-bright.CodeMirror {background: #000000; color: #eaeaea;}
+.cm-s-tomorrow-night-bright div.CodeMirror-selected {background: #424242 !important;}
+.cm-s-tomorrow-night-bright .CodeMirror-gutters {background: #000000; border-right: 0px;}
+.cm-s-tomorrow-night-bright .CodeMirror-guttermarker { color: #e78c45; }
+.cm-s-tomorrow-night-bright .CodeMirror-guttermarker-subtle { color: #777; }
+.cm-s-tomorrow-night-bright .CodeMirror-linenumber {color: #424242;}
+.cm-s-tomorrow-night-bright .CodeMirror-cursor {border-left: 1px solid #6A6A6A !important;}
+
+.cm-s-tomorrow-night-bright span.cm-comment {color: #d27b53;}
+.cm-s-tomorrow-night-bright span.cm-atom {color: #a16a94;}
+.cm-s-tomorrow-night-bright span.cm-number {color: #a16a94;}
+
+.cm-s-tomorrow-night-bright span.cm-property, .cm-s-tomorrow-night-bright span.cm-attribute {color: #99cc99;}
+.cm-s-tomorrow-night-bright span.cm-keyword {color: #d54e53;}
+.cm-s-tomorrow-night-bright span.cm-string {color: #e7c547;}
+
+.cm-s-tomorrow-night-bright span.cm-variable {color: #b9ca4a;}
+.cm-s-tomorrow-night-bright span.cm-variable-2 {color: #7aa6da;}
+.cm-s-tomorrow-night-bright span.cm-def {color: #e78c45;}
+.cm-s-tomorrow-night-bright span.cm-bracket {color: #eaeaea;}
+.cm-s-tomorrow-night-bright span.cm-tag {color: #d54e53;}
+.cm-s-tomorrow-night-bright span.cm-link {color: #a16a94;}
+.cm-s-tomorrow-night-bright span.cm-error {background: #d54e53; color: #6A6A6A;}
+
+.cm-s-tomorrow-night-bright .CodeMirror-activeline-background {background: #2a2a2a !important;}
+.cm-s-tomorrow-night-bright .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
diff --git a/src/main/resources/codemirror/theme/tomorrow-night-eighties.css b/src/main/resources/codemirror/theme/tomorrow-night-eighties.css
new file mode 100755
index 0000000..a8ee8f5
--- /dev/null
+++ b/src/main/resources/codemirror/theme/tomorrow-night-eighties.css
@@ -0,0 +1,38 @@
+/*
+
+    Name:       Tomorrow Night - Eighties
+    Author:     Chris Kempson
+
+    CodeMirror template by Jan T. Sott (https://github.com/idleberg/base16-codemirror)
+    Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16)
+
+*/
+
+.cm-s-tomorrow-night-eighties.CodeMirror {background: #000000; color: #CCCCCC;}
+.cm-s-tomorrow-night-eighties div.CodeMirror-selected {background: #2D2D2D !important;}
+.cm-s-tomorrow-night-eighties .CodeMirror-line::selection, .cm-s-tomorrow-night-eighties .CodeMirror-line > span::selection, .cm-s-tomorrow-night-eighties .CodeMirror-line > span > span::selection { background: rgba(45, 45, 45, 0.99); }
+.cm-s-tomorrow-night-eighties .CodeMirror-line::-moz-selection, .cm-s-tomorrow-night-eighties .CodeMirror-line > span::-moz-selection, .cm-s-tomorrow-night-eighties .CodeMirror-line > span > span::-moz-selection { background: rgba(45, 45, 45, 0.99); }
+.cm-s-tomorrow-night-eighties .CodeMirror-gutters {background: #000000; border-right: 0px;}
+.cm-s-tomorrow-night-eighties .CodeMirror-guttermarker { color: #f2777a; }
+.cm-s-tomorrow-night-eighties .CodeMirror-guttermarker-subtle { color: #777; }
+.cm-s-tomorrow-night-eighties .CodeMirror-linenumber {color: #515151;}
+.cm-s-tomorrow-night-eighties .CodeMirror-cursor {border-left: 1px solid #6A6A6A !important;}
+
+.cm-s-tomorrow-night-eighties span.cm-comment {color: #d27b53;}
+.cm-s-tomorrow-night-eighties span.cm-atom {color: #a16a94;}
+.cm-s-tomorrow-night-eighties span.cm-number {color: #a16a94;}
+
+.cm-s-tomorrow-night-eighties span.cm-property, .cm-s-tomorrow-night-eighties span.cm-attribute {color: #99cc99;}
+.cm-s-tomorrow-night-eighties span.cm-keyword {color: #f2777a;}
+.cm-s-tomorrow-night-eighties span.cm-string {color: #ffcc66;}
+
+.cm-s-tomorrow-night-eighties span.cm-variable {color: #99cc99;}
+.cm-s-tomorrow-night-eighties span.cm-variable-2 {color: #6699cc;}
+.cm-s-tomorrow-night-eighties span.cm-def {color: #f99157;}
+.cm-s-tomorrow-night-eighties span.cm-bracket {color: #CCCCCC;}
+.cm-s-tomorrow-night-eighties span.cm-tag {color: #f2777a;}
+.cm-s-tomorrow-night-eighties span.cm-link {color: #a16a94;}
+.cm-s-tomorrow-night-eighties span.cm-error {background: #f2777a; color: #6A6A6A;}
+
+.cm-s-tomorrow-night-eighties .CodeMirror-activeline-background {background: #343600 !important;}
+.cm-s-tomorrow-night-eighties .CodeMirror-matchingbracket { text-decoration: underline; color: white !important;}
diff --git a/src/main/resources/codemirror/theme/ttcn.css b/src/main/resources/codemirror/theme/ttcn.css
new file mode 100755
index 0000000..9c2e9a6
--- /dev/null
+++ b/src/main/resources/codemirror/theme/ttcn.css
@@ -0,0 +1,65 @@
+.cm-quote {color: #090;}
+.cm-negative {color: #d44;}
+.cm-positive {color: #292;}
+.cm-header, .cm-strong {font-weight: bold;}
+.cm-em {font-style: italic;}
+.cm-link {text-decoration: underline;}
+.cm-strikethrough {text-decoration: line-through;}
+.cm-header {color: #00f; font-weight: bold;}
+
+.cm-atom {color: #219;}
+.cm-attribute {color: #00c;}
+.cm-bracket {color: #997;}
+.cm-comment {color: #333333;}
+.cm-def {color: #00f;}
+.cm-em {font-style: italic;}
+.cm-error {color: #f00;}
+.cm-hr {color: #999;}
+.cm-invalidchar {color: #f00;}
+.cm-keyword {font-weight:bold}
+.cm-link {color: #00c; text-decoration: underline;}
+.cm-meta {color: #555;}
+.cm-negative {color: #d44;}
+.cm-positive {color: #292;}
+.cm-qualifier {color: #555;}
+.cm-strikethrough {text-decoration: line-through;}
+.cm-string {color: #006400;}
+.cm-string-2 {color: #f50;}
+.cm-strong {font-weight: bold;}
+.cm-tag {color: #170;}
+.cm-variable {color: #8B2252;}
+.cm-variable-2 {color: #05a;}
+.cm-variable-3 {color: #085;}
+
+.cm-s-default .cm-error {color: #f00;}
+.cm-invalidchar {color: #f00;}
+
+/* ASN */
+.cm-s-ttcn .cm-accessTypes,
+.cm-s-ttcn .cm-compareTypes {color: #27408B}
+.cm-s-ttcn .cm-cmipVerbs {color: #8B2252}
+.cm-s-ttcn .cm-modifier {color:#D2691E}
+.cm-s-ttcn .cm-status {color:#8B4545}
+.cm-s-ttcn .cm-storage {color:#A020F0}
+.cm-s-ttcn .cm-tags {color:#006400}
+
+/* CFG */
+.cm-s-ttcn .cm-externalCommands {color: #8B4545; font-weight:bold}
+.cm-s-ttcn .cm-fileNCtrlMaskOptions,
+.cm-s-ttcn .cm-sectionTitle {color: #2E8B57; font-weight:bold}
+
+/* TTCN */
+.cm-s-ttcn .cm-booleanConsts,
+.cm-s-ttcn .cm-otherConsts,
+.cm-s-ttcn .cm-verdictConsts {color: #006400}
+.cm-s-ttcn .cm-configOps,
+.cm-s-ttcn .cm-functionOps,
+.cm-s-ttcn .cm-portOps,
+.cm-s-ttcn .cm-sutOps,
+.cm-s-ttcn .cm-timerOps,
+.cm-s-ttcn .cm-verdictOps {color: #0000FF}
+.cm-s-ttcn .cm-preprocessor,
+.cm-s-ttcn .cm-templateMatch,
+.cm-s-ttcn .cm-ttcn3Macros {color: #27408B}
+.cm-s-ttcn .cm-types {color: #A52A2A; font-weight:bold}
+.cm-s-ttcn .cm-visibilityModifiers {font-weight:bold}
diff --git a/src/main/resources/codemirror/theme/twilight.css b/src/main/resources/codemirror/theme/twilight.css
new file mode 100755
index 0000000..360d44a
--- /dev/null
+++ b/src/main/resources/codemirror/theme/twilight.css
@@ -0,0 +1,32 @@
+.cm-s-twilight.CodeMirror { background: #141414; color: #f7f7f7; } /**/
+.cm-s-twilight .CodeMirror-selected { background: #323232 !important; } /**/
+.cm-s-twilight .CodeMirror-line::selection, .cm-s-twilight .CodeMirror-line > span::selection, .cm-s-twilight .CodeMirror-line > span > span::selection { background: rgba(50, 50, 50, 0.99); }
+.cm-s-twilight .CodeMirror-line::-moz-selection, .cm-s-twilight .CodeMirror-line > span::-moz-selection, .cm-s-twilight .CodeMirror-line > span > span::-moz-selection { background: rgba(50, 50, 50, 0.99); }
+
+.cm-s-twilight .CodeMirror-gutters { background: #222; border-right: 1px solid #aaa; }
+.cm-s-twilight .CodeMirror-guttermarker { color: white; }
+.cm-s-twilight .CodeMirror-guttermarker-subtle { color: #aaa; }
+.cm-s-twilight .CodeMirror-linenumber { color: #aaa; }
+.cm-s-twilight .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-twilight .cm-keyword {  color: #f9ee98; } /**/
+.cm-s-twilight .cm-atom { color: #FC0; }
+.cm-s-twilight .cm-number { color:  #ca7841; } /**/
+.cm-s-twilight .cm-def { color: #8DA6CE; }
+.cm-s-twilight span.cm-variable-2, .cm-s-twilight span.cm-tag { color: #607392; } /**/
+.cm-s-twilight span.cm-variable-3, .cm-s-twilight span.cm-def { color: #607392; } /**/
+.cm-s-twilight .cm-operator { color: #cda869; } /**/
+.cm-s-twilight .cm-comment { color:#777; font-style:italic; font-weight:normal; } /**/
+.cm-s-twilight .cm-string { color:#8f9d6a; font-style:italic; } /**/
+.cm-s-twilight .cm-string-2 { color:#bd6b18 } /*?*/
+.cm-s-twilight .cm-meta { background-color:#141414; color:#f7f7f7; } /*?*/
+.cm-s-twilight .cm-builtin { color: #cda869; } /*?*/
+.cm-s-twilight .cm-tag { color: #997643; } /**/
+.cm-s-twilight .cm-attribute { color: #d6bb6d; } /*?*/
+.cm-s-twilight .cm-header { color: #FF6400; }
+.cm-s-twilight .cm-hr { color: #AEAEAE; }
+.cm-s-twilight .cm-link {   color:#ad9361; font-style:italic; text-decoration:none; } /**/
+.cm-s-twilight .cm-error { border-bottom: 1px solid red; }
+
+.cm-s-twilight .CodeMirror-activeline-background {background: #27282E !important;}
+.cm-s-twilight .CodeMirror-matchingbracket {outline:1px solid grey; color:white !important;}
diff --git a/src/main/resources/codemirror/theme/vibrant-ink.css b/src/main/resources/codemirror/theme/vibrant-ink.css
new file mode 100755
index 0000000..8d3e99d
--- /dev/null
+++ b/src/main/resources/codemirror/theme/vibrant-ink.css
@@ -0,0 +1,34 @@
+/* Taken from the popular Visual Studio Vibrant Ink Schema */
+
+.cm-s-vibrant-ink.CodeMirror { background: black; color: white; }
+.cm-s-vibrant-ink .CodeMirror-selected { background: #35493c !important; }
+.cm-s-vibrant-ink .CodeMirror-line::selection, .cm-s-vibrant-ink .CodeMirror-line > span::selection, .cm-s-vibrant-ink .CodeMirror-line > span > span::selection { background: rgba(53, 73, 60, 0.99); }
+.cm-s-vibrant-ink .CodeMirror-line::-moz-selection, .cm-s-vibrant-ink .CodeMirror-line > span::-moz-selection, .cm-s-vibrant-ink .CodeMirror-line > span > span::-moz-selection { background: rgba(53, 73, 60, 0.99); }
+
+.cm-s-vibrant-ink .CodeMirror-gutters { background: #002240; border-right: 1px solid #aaa; }
+.cm-s-vibrant-ink .CodeMirror-guttermarker { color: white; }
+.cm-s-vibrant-ink .CodeMirror-guttermarker-subtle { color: #d0d0d0; }
+.cm-s-vibrant-ink .CodeMirror-linenumber { color: #d0d0d0; }
+.cm-s-vibrant-ink .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-vibrant-ink .cm-keyword {  color: #CC7832; }
+.cm-s-vibrant-ink .cm-atom { color: #FC0; }
+.cm-s-vibrant-ink .cm-number { color:  #FFEE98; }
+.cm-s-vibrant-ink .cm-def { color: #8DA6CE; }
+.cm-s-vibrant-ink span.cm-variable-2, .cm-s-vibrant span.cm-tag { color: #FFC66D }
+.cm-s-vibrant-ink span.cm-variable-3, .cm-s-vibrant span.cm-def { color: #FFC66D }
+.cm-s-vibrant-ink .cm-operator { color: #888; }
+.cm-s-vibrant-ink .cm-comment { color: gray; font-weight: bold; }
+.cm-s-vibrant-ink .cm-string { color:  #A5C25C }
+.cm-s-vibrant-ink .cm-string-2 { color: red }
+.cm-s-vibrant-ink .cm-meta { color: #D8FA3C; }
+.cm-s-vibrant-ink .cm-builtin { color: #8DA6CE; }
+.cm-s-vibrant-ink .cm-tag { color: #8DA6CE; }
+.cm-s-vibrant-ink .cm-attribute { color: #8DA6CE; }
+.cm-s-vibrant-ink .cm-header { color: #FF6400; }
+.cm-s-vibrant-ink .cm-hr { color: #AEAEAE; }
+.cm-s-vibrant-ink .cm-link { color: blue; }
+.cm-s-vibrant-ink .cm-error { border-bottom: 1px solid red; }
+
+.cm-s-vibrant-ink .CodeMirror-activeline-background {background: #27282E !important;}
+.cm-s-vibrant-ink .CodeMirror-matchingbracket {outline:1px solid grey; color:white !important;}
diff --git a/src/main/resources/codemirror/theme/xq-dark.css b/src/main/resources/codemirror/theme/xq-dark.css
new file mode 100755
index 0000000..5cdfe8f
--- /dev/null
+++ b/src/main/resources/codemirror/theme/xq-dark.css
@@ -0,0 +1,53 @@
+/*
+Copyright (C) 2011 by MarkLogic Corporation
+Author: Mike Brevoort <mike@brevoort.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+.cm-s-xq-dark.CodeMirror { background: #0a001f; color: #f8f8f8; }
+.cm-s-xq-dark .CodeMirror-selected { background: #27007A !important; }
+.cm-s-xq-dark .CodeMirror-line::selection, .cm-s-xq-dark .CodeMirror-line > span::selection, .cm-s-xq-dark .CodeMirror-line > span > span::selection { background: rgba(39, 0, 122, 0.99); }
+.cm-s-xq-dark .CodeMirror-line::-moz-selection, .cm-s-xq-dark .CodeMirror-line > span::-moz-selection, .cm-s-xq-dark .CodeMirror-line > span > span::-moz-selection { background: rgba(39, 0, 122, 0.99); }
+.cm-s-xq-dark .CodeMirror-gutters { background: #0a001f; border-right: 1px solid #aaa; }
+.cm-s-xq-dark .CodeMirror-guttermarker { color: #FFBD40; }
+.cm-s-xq-dark .CodeMirror-guttermarker-subtle { color: #f8f8f8; }
+.cm-s-xq-dark .CodeMirror-linenumber { color: #f8f8f8; }
+.cm-s-xq-dark .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-xq-dark span.cm-keyword {color: #FFBD40;}
+.cm-s-xq-dark span.cm-atom {color: #6C8CD5;}
+.cm-s-xq-dark span.cm-number {color: #164;}
+.cm-s-xq-dark span.cm-def {color: #FFF; text-decoration:underline;}
+.cm-s-xq-dark span.cm-variable {color: #FFF;}
+.cm-s-xq-dark span.cm-variable-2 {color: #EEE;}
+.cm-s-xq-dark span.cm-variable-3 {color: #DDD;}
+.cm-s-xq-dark span.cm-property {}
+.cm-s-xq-dark span.cm-operator {}
+.cm-s-xq-dark span.cm-comment {color: gray;}
+.cm-s-xq-dark span.cm-string {color: #9FEE00;}
+.cm-s-xq-dark span.cm-meta {color: yellow;}
+.cm-s-xq-dark span.cm-qualifier {color: #FFF700;}
+.cm-s-xq-dark span.cm-builtin {color: #30a;}
+.cm-s-xq-dark span.cm-bracket {color: #cc7;}
+.cm-s-xq-dark span.cm-tag {color: #FFBD40;}
+.cm-s-xq-dark span.cm-attribute {color: #FFF700;}
+.cm-s-xq-dark span.cm-error {color: #f00;}
+
+.cm-s-xq-dark .CodeMirror-activeline-background {background: #27282E !important;}
+.cm-s-xq-dark .CodeMirror-matchingbracket {outline:1px solid grey; color:white !important;}
\ No newline at end of file
diff --git a/src/main/resources/codemirror/theme/xq-light.css b/src/main/resources/codemirror/theme/xq-light.css
new file mode 100755
index 0000000..20b5c79
--- /dev/null
+++ b/src/main/resources/codemirror/theme/xq-light.css
@@ -0,0 +1,43 @@
+/*
+Copyright (C) 2011 by MarkLogic Corporation
+Author: Mike Brevoort <mike@brevoort.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+.cm-s-xq-light span.cm-keyword {line-height: 1em; font-weight: bold; color: #5A5CAD; }
+.cm-s-xq-light span.cm-atom {color: #6C8CD5;}
+.cm-s-xq-light span.cm-number {color: #164;}
+.cm-s-xq-light span.cm-def {text-decoration:underline;}
+.cm-s-xq-light span.cm-variable {color: black; }
+.cm-s-xq-light span.cm-variable-2 {color:black;}
+.cm-s-xq-light span.cm-variable-3 {color: black; }
+.cm-s-xq-light span.cm-property {}
+.cm-s-xq-light span.cm-operator {}
+.cm-s-xq-light span.cm-comment {color: #0080FF; font-style: italic;}
+.cm-s-xq-light span.cm-string {color: red;}
+.cm-s-xq-light span.cm-meta {color: yellow;}
+.cm-s-xq-light span.cm-qualifier {color: grey}
+.cm-s-xq-light span.cm-builtin {color: #7EA656;}
+.cm-s-xq-light span.cm-bracket {color: #cc7;}
+.cm-s-xq-light span.cm-tag {color: #3F7F7F;}
+.cm-s-xq-light span.cm-attribute {color: #7F007F;}
+.cm-s-xq-light span.cm-error {color: #f00;}
+
+.cm-s-xq-light .CodeMirror-activeline-background {background: #e8f2ff !important;}
+.cm-s-xq-light .CodeMirror-matchingbracket {outline:1px solid grey;color:black !important;background:yellow;}
\ No newline at end of file
diff --git a/src/main/resources/codemirror/theme/yeti.css b/src/main/resources/codemirror/theme/yeti.css
new file mode 100755
index 0000000..cb12bb5
--- /dev/null
+++ b/src/main/resources/codemirror/theme/yeti.css
@@ -0,0 +1,86 @@
+/*
+
+    Name:       yeti
+    Author:     Michael Kaminsky (http://github.com/mkaminsky11)
+
+    Original yeti color scheme by Jesse Weed (https://github.com/jesseweed/yeti-syntax)
+
+*/
+
+
+.cm-s-yeti.CodeMirror {
+  background-color: #ECEAE8 !important;
+  color: #d1c9c0 !important;
+  border: none;
+}
+
+.cm-s-yeti .CodeMirror-gutters{
+  color: #adaba6;
+  background-color: #E5E1DB;
+  border: none;
+}
+.cm-s-yeti .CodeMirror-cursor {
+  border-left: solid thin #d1c9c0 !important;
+}
+.cm-s-yeti .CodeMirror-linenumber {
+  color: #adaba6;
+}
+.cm-s-yeti.CodeMirror-focused .CodeMirror-selected {
+  background: #DCD8D2;
+}
+.cm-s-yeti .CodeMirror-line::selection, .cm-s-yeti .CodeMirror-line > span::selection, .cm-s-yeti .CodeMirror-line > span > span::selection {
+  background: #DCD8D2;
+}
+.cm-s-yeti .CodeMirror-line::-moz-selection, .cm-s-yeti .CodeMirror-line > span::-moz-selection, .cm-s-yeti .CodeMirror-line > span > span::-moz-selection {
+  background: #DCD8D2;
+}
+.cm-s-yeti span.cm-comment {
+  color: #d4c8be;
+}
+.cm-s-yeti span.cm-string, .cm-s-yeti span.cm-string-2 {
+  color: #96c0d8;
+}
+.cm-s-yeti span.cm-number {
+  color: #a074c4;
+}
+.cm-s-yeti span.cm-variable {
+  color: #55b5db;
+}
+.cm-s-yeti span.cm-variable-2 {
+  color: #a074c4;
+}
+.cm-s-yeti span.cm-def {
+  color: #55b5db;
+}
+.cm-s-yeti span.cm-operator {
+  color: #9fb96e;
+}
+.cm-s-yeti span.cm-keyword {
+  color: #9fb96e;
+}
+.cm-s-yeti span.cm-atom {
+  color: #a074c4;
+}
+.cm-s-yeti span.cm-meta {
+  color: #96c0d8;
+}
+.cm-s-yeti span.cm-tag {
+  color: #96c0d8;
+}
+.cm-s-yeti span.cm-attribute {
+  color: #9fb96e;
+}
+.cm-s-yeti span.cm-qualifier {
+  color: #96c0d8;
+}
+.cm-s-yeti span.cm-property {
+  color: #a074c4;
+}
+.cm-s-yeti span.cm-builtin {
+  color: #a074c4;
+}
+.cm-s-yeti span.cm-variable-3 {
+  color: #96c0d8;
+}
+.cm-s-yeti .CodeMirror-activeline-background {background: #E7E4E0 !important;}
+.cm-s-yeti .CodeMirror-matchingbracket { text-decoration: underline;}
\ No newline at end of file
diff --git a/src/main/resources/codemirror/theme/zenburn.css b/src/main/resources/codemirror/theme/zenburn.css
new file mode 100755
index 0000000..f817198
--- /dev/null
+++ b/src/main/resources/codemirror/theme/zenburn.css
@@ -0,0 +1,37 @@
+/**
+ * "
+ *  Using Zenburn color palette from the Emacs Zenburn Theme
+ *  https://github.com/bbatsov/zenburn-emacs/blob/master/zenburn-theme.el
+ *
+ *  Also using parts of https://github.com/xavi/coderay-lighttable-theme
+ * "
+ * From: https://github.com/wisenomad/zenburn-lighttable-theme/blob/master/zenburn.css
+ */
+
+.cm-s-zenburn .CodeMirror-gutters { background: #3f3f3f !important; }
+.cm-s-zenburn .CodeMirror-foldgutter-open, .CodeMirror-foldgutter-folded { color: #999; }
+.cm-s-zenburn .CodeMirror-cursor { border-left: 1px solid white !important; }
+.cm-s-zenburn { background-color: #3f3f3f; color: #dcdccc; }
+.cm-s-zenburn span.cm-builtin { color: #dcdccc; font-weight: bold; }
+.cm-s-zenburn span.cm-comment { color: #7f9f7f; }
+.cm-s-zenburn span.cm-keyword { color: #f0dfaf; font-weight: bold; }
+.cm-s-zenburn span.cm-atom { color: #bfebbf; }
+.cm-s-zenburn span.cm-def { color: #dcdccc; }
+.cm-s-zenburn span.cm-variable { color: #dfaf8f; }
+.cm-s-zenburn span.cm-variable-2 { color: #dcdccc; }
+.cm-s-zenburn span.cm-string { color: #cc9393; }
+.cm-s-zenburn span.cm-string-2 { color: #cc9393; }
+.cm-s-zenburn span.cm-number { color: #dcdccc; }
+.cm-s-zenburn span.cm-tag { color: #93e0e3; }
+.cm-s-zenburn span.cm-property { color: #dfaf8f; }
+.cm-s-zenburn span.cm-attribute { color: #dfaf8f; }
+.cm-s-zenburn span.cm-qualifier { color: #7cb8bb; }
+.cm-s-zenburn span.cm-meta { color: #f0dfaf; }
+.cm-s-zenburn span.cm-header { color: #f0efd0; }
+.cm-s-zenburn span.cm-operator { color: #f0efd0; }
+.cm-s-zenburn span.CodeMirror-matchingbracket { box-sizing: border-box; background: transparent; border-bottom: 1px solid; }
+.cm-s-zenburn span.CodeMirror-nonmatchingbracket { border-bottom: 1px solid; background: none; }
+.cm-s-zenburn .CodeMirror-activeline { background: #000000; }
+.cm-s-zenburn .CodeMirror-activeline-background { background: #000000; }
+.cm-s-zenburn .CodeMirror-selected { background: #545454; }
+.cm-s-zenburn .CodeMirror-focused .CodeMirror-selected { background: #4f4f4f; }
diff --git a/src/main/resources/fxml/editor.fxml b/src/main/resources/fxml/editor.fxml
new file mode 100644
index 0000000..c24b62b
--- /dev/null
+++ b/src/main/resources/fxml/editor.fxml
@@ -0,0 +1,130 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.input.*?>
+<?import javafx.scene.web.*?>
+<?import java.lang.*?>
+<?import java.net.*?>
+<?import java.util.*?>
+<?import javafx.scene.*?>
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.*?>
+
+<AnchorPane id="AnchorPane" prefHeight="400.0" prefWidth="600.0" styleClass="mainFxmlClass" xmlns="http://javafx.com/javafx/8.0.40" xmlns:fx="http://javafx.com/fxml/1" fx:controller="jace.ide.IdeController">
+    <stylesheets>
+        <URL value="@/styles/editor.css" />
+    </stylesheets>
+   <children>
+      <VBox layoutX="116.0" layoutY="63.0" prefHeight="200.0" prefWidth="100.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
+         <children>
+            <MenuBar id="menuBar">
+              <menus>
+                <Menu mnemonicParsing="false" text="File">
+                  <items>
+                        <Menu mnemonicParsing="false" text="New...">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="N" control="UP" meta="UP" shift="UP" shortcut="DOWN" />
+                           </accelerator>
+                           <items>
+                              <MenuItem mnemonicParsing="false" onAction="#newAssemblyListingClicked" text="Assembly Listing" />
+                              <MenuItem mnemonicParsing="false" onAction="#newApplesoftBasicClicked" text="Applesoft Basic Listing" />
+                              <MenuItem mnemonicParsing="false" onAction="#newPlainTextClicked" text="Plain Text" />
+                              <MenuItem mnemonicParsing="false" onAction="#newHexdataClicked" text="Data (Hex)" />
+                           </items>
+                        </Menu>
+                        <SeparatorMenuItem mnemonicParsing="false" />
+                        <MenuItem mnemonicParsing="false" onAction="#onOpenClicked" text="Open">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="O" control="UP" meta="UP" shift="UP" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                        <Menu disable="true" mnemonicParsing="false" text="Open Recent" />
+                        <SeparatorMenuItem mnemonicParsing="false" />
+                        <MenuItem fx:id="saveMenuItem" disable="true" mnemonicParsing="false" onAction="#onSaveClicked" text="Save">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="S" control="UP" meta="UP" shift="UP" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                        <MenuItem fx:id="saveAllMenuItem" disable="true" mnemonicParsing="false" onAction="#onSaveAllClicked" text="Save All" />
+                        <MenuItem fx:id="saveAsMenuItem" disable="true" mnemonicParsing="false" onAction="#onSaveAsClicked" text="Save As...">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="S" control="UP" meta="UP" shift="DOWN" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                        <SeparatorMenuItem mnemonicParsing="false" />
+                    <MenuItem fx:id="closeMenuItem" disable="true" mnemonicParsing="false" onAction="#onCloseClicked" text="Close">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="W" control="UP" meta="UP" shift="UP" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                        <MenuItem fx:id="closeAllMenuItem" disable="true" mnemonicParsing="false" onAction="#onCloseAllClicked" text="Close All">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="W" control="UP" meta="UP" shift="DOWN" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                  </items>
+                </Menu>
+                <Menu fx:id="editMenu" mnemonicParsing="false" text="Edit">
+                  <items>
+                    <MenuItem mnemonicParsing="false" text="Cut" />
+                        <MenuItem mnemonicParsing="false" text="Copy" />
+                        <MenuItem mnemonicParsing="false" text="Paste" />
+                        <SeparatorMenuItem mnemonicParsing="false" />
+                        <MenuItem mnemonicParsing="false" text="Undo" />
+                        <MenuItem mnemonicParsing="false" text="Redo" />
+                        <SeparatorMenuItem mnemonicParsing="false" />
+                        <MenuItem mnemonicParsing="false" text="Find/Replace" />
+                        <MenuItem mnemonicParsing="false" text="Go to line..." />
+                  </items>
+                </Menu>
+                  <Menu fx:id="runMenu" mnemonicParsing="false" text="Run">
+                    <items>
+                      <MenuItem mnemonicParsing="false" onAction="#testCompileClicked" text="Test-compile program">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="T" control="UP" meta="UP" shift="UP" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                        <MenuItem mnemonicParsing="false" onAction="#executeClicked" text="Execute program">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="R" control="UP" meta="UP" shift="UP" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                        <MenuItem mnemonicParsing="false" onAction="#viewCompilerOutputClicked" text="View compiler output">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="DIGIT1" control="UP" meta="UP" shift="UP" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                        <MenuItem mnemonicParsing="false" onAction="#viewSymbolTableClicked" text="View symbol table">
+                           <accelerator>
+                              <KeyCodeCombination alt="UP" code="DIGIT2" control="UP" meta="UP" shift="UP" shortcut="DOWN" />
+                           </accelerator></MenuItem>
+                    </items>
+                  </Menu>
+                  <Menu mnemonicParsing="false" text="Options">
+                     <items>
+                        <Menu mnemonicParsing="false" text="Auto-compile">
+                          <items>
+                              <RadioMenuItem mnemonicParsing="false" selected="true" text="Automatically">
+                                 <toggleGroup>
+                                    <ToggleGroup fx:id="autocompile" />
+                                 </toggleGroup>
+                              </RadioMenuItem>
+                              <RadioMenuItem mnemonicParsing="false" text="When saving" toggleGroup="$autocompile" />
+                              <RadioMenuItem mnemonicParsing="false" text="Disabled" toggleGroup="$autocompile" />
+                          </items>
+                        </Menu>
+                        <CheckMenuItem mnemonicParsing="false" text="Show line numbers" />
+                     </items>
+                  </Menu>
+                <Menu mnemonicParsing="false" text="Help">
+                  <items>
+                    <MenuItem mnemonicParsing="false" text="About Jace IDE" />
+                        <MenuItem mnemonicParsing="false" text="Acme Help" />
+                        <Menu mnemonicParsing="false" text="Cheat sheets">
+                          <items>
+                              <MenuItem mnemonicParsing="false" text="6502/65C02 Opcodes" />
+                            <MenuItem mnemonicParsing="false" text="Zero page maps" />
+                              <MenuItem mnemonicParsing="false" text="Peeks, pokes and calls" />
+                          </items>
+                        </Menu>
+                  </items>
+                </Menu>
+              </menus>
+            </MenuBar>
+            <TabPane id="documentTabs" fx:id="tabPane" prefHeight="342.0" prefWidth="600.0" tabClosingPolicy="ALL_TABS" VBox.vgrow="ALWAYS" />
+            <ToolBar id="toolBar" fx:id="statusBar" prefHeight="40.0" prefWidth="200.0" />
+         </children>
+      </VBox>
+   </children>
+</AnchorPane>
diff --git a/src/main/resources/styles/editor.css b/src/main/resources/styles/editor.css
new file mode 100644
index 0000000..a10957e
--- /dev/null
+++ b/src/main/resources/styles/editor.css
@@ -0,0 +1,7 @@
+/*
+ * Empty Stylesheet file.
+ */
+
+.mainFxmlClass {
+
+}