Remove some dead code in the MIPS stuff, and run rebuild.sh.

Change-Id: I7c3226efe97e6e5678b757eb2350d0eeb2efd8b5
diff --git a/vm/compiler/codegen/mips/CodegenDriver.cpp b/vm/compiler/codegen/mips/CodegenDriver.cpp
index 6ef2ce4..3dd95ae 100644
--- a/vm/compiler/codegen/mips/CodegenDriver.cpp
+++ b/vm/compiler/codegen/mips/CodegenDriver.cpp
@@ -1561,7 +1561,6 @@
         case OP_UNUSED_73:
         case OP_UNUSED_79:
         case OP_UNUSED_7A:
-        case OP_DISPATCH_FF:
             LOGE("Codegen: got unused opcode %#x",dalvikOpcode);
             return true;
         case OP_NOP:
diff --git a/vm/mterp/config-mips b/vm/mterp/config-mips
index 8c50858..0dc80e8 100644
--- a/vm/mterp/config-mips
+++ b/vm/mterp/config-mips
@@ -50,9 +50,6 @@
 # OP_BREAKPOINT needs explicit testing
     op OP_BREAKPOINT c
 
-# OP_DISPATCH_FF needs explicit testing
-    op OP_DISPATCH_FF c
-
 op-end
 
 # "helper" code for C; include if you use any of the C stubs (this generates
diff --git a/vm/mterp/out/InterpAsm-mips.S b/vm/mterp/out/InterpAsm-mips.S
index 734ae91..98837fd 100644
--- a/vm/mterp/out/InterpAsm-mips.S
+++ b/vm/mterp/out/InterpAsm-mips.S
@@ -9191,3723 +9191,11 @@
 
 /* ------------------------------ */
     .balign 128
-.L_OP_DISPATCH_FF: /* 0xff */
-    /* (stub) */
-    SAVE_PC_TO_SELF()            # only need to export PC and FP
-    SAVE_FP_TO_SELF()
-    move        a0, rSELF        # self is first arg to function
-    JAL(dvmMterp_OP_DISPATCH_FF)      # call
-    LOAD_PC_FROM_SELF()          # retrieve updated values
-    LOAD_FP_FROM_SELF()
-    FETCH_INST()                 # load next instruction from rPC
-    GET_INST_OPCODE(t0)          # ...trim down to just the opcode
-    GOTO_OPCODE(t0)              # ...and jump to the handler
-/* ------------------------------ */
-    .balign 128
-.L_OP_CONST_CLASS_JUMBO: /* 0x100 */
-/* File: mips/OP_CONST_CLASS_JUMBO.S */
-    /* const-class/jumbo vBBBB, Class@AAAAAAAA */
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- self->methodClassDex
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResClasses(a2, a2) #  a2 <- dvmDex->pResClasses
-    sll       a1,a1,16
-    or        a1, a0, a1                  # a1<- AAAAaaaa
-    FETCH(rOBJ, 3)                        # rOBJ<- BBBB
-    LOAD_eas2(v0, a2, a1)                  #  v0 <- pResClasses[BBBB]
-
-    bnez      v0, .LOP_CONST_CLASS_JUMBO_resolve      #  v0!=0 => resolved-ok
-    /*
-     * Continuation if the Class has not yet been resolved.
-     *  a1: AAAAAAAA (Class ref)
-     *  rOBJ: target register
-     */
-    EXPORT_PC()
-    LOAD_rSELF_method(a0)                  #  a0 <- self->method
-    li        a2, 1                        #  a2 <- true
-    LOAD_base_offMethod_clazz(a0, a0)      #  a0 <- method->clazz
-    JAL(dvmResolveClass)                   #  v0 <- Class reference
-    # failed==0?
-    beqz      v0, common_exceptionThrown   #  yup, handle the exception
-
-.LOP_CONST_CLASS_JUMBO_resolve:
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(v0, rOBJ, t0)            #  vBBBB <- v0
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_CHECK_CAST_JUMBO: /* 0x101 */
-/* File: mips/OP_CHECK_CAST_JUMBO.S */
-    /*
-     * Check to see if a cast from one class to another is allowed.
-     */
-    /* check-cast/ jumbo vBBBB, class #AAAAAAAA */
-    FETCH(a0, 1)                        # a0<- aaaa (lo)
-    FETCH(a2, 2)                        # a2<- AAAA (hi)
-    FETCH(a3, 3)                        # a3<- BBBB
-    sll    a2,a2,16
-    or     a2, a0, a2                   # a2<- AAAAaaaa
-
-    GET_VREG(rOBJ, a3)                          # rOBJ<- object
-    LOAD_rSELF_methodClassDex(a0)   # a0<- pDvmDex
-    LOAD_base_offDvmDex_pResClasses(a0, a0) # a0<- pDvmDex->pResClasses
-                                                # is object null?
-    beqz     rOBJ, .LOP_CHECK_CAST_JUMBO_okay             # null obj, cast always succeeds
-    LOAD_eas2(a1, a0, a2)           # a1<- resolved class
-    LOAD_base_offObject_clazz(a0, rOBJ)   # a0<- obj->clazz
-                                                # have we resolved this before?
-    beqz    a1, .LOP_CHECK_CAST_JUMBO_resolve             # not resolved, do it now
-.LOP_CHECK_CAST_JUMBO_resolved:
-                                                # same class (trivial success)?
-    bne     a0, a1, .LOP_CHECK_CAST_JUMBO_fullcheck       # no, do full check
-    b       .LOP_CHECK_CAST_JUMBO_okay                    # yes, finish up
-
-    /*
-     * Trivial test failed, need to perform full check.  This is common.
-     *  a0 holds obj->clazz
-     *  a1 holds class resolved from BBBB
-     *  rOBJ holds object
-     */
-.LOP_CHECK_CAST_JUMBO_fullcheck:
-    move      rBIX,a1                      #  avoid ClassObject getting clobbered
-    JAL(dvmInstanceofNonTrivial)    # v0<- boolean result
-                                                # failed?
-    bnez    v0, .LOP_CHECK_CAST_JUMBO_okay                # no, success
-    b       .LOP_CHECK_CAST_JUMBO_castfailure
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_INSTANCE_OF_JUMBO: /* 0x102 */
-/* File: mips/OP_INSTANCE_OF_JUMBO.S */
-    /*
-     * Check to see if an object reference is an instance of a class.
-     *
-     * Most common situation is a non-null object, being compared against
-     * an already-resolved class.
-     *
-     * TODO: convert most of this into a common subroutine, shared with
-     *       OP_INSTANCE_OF.S.
-     */
-    /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */
-    FETCH(a3, 4)                           # a3<- vCCCC
-    FETCH(rOBJ, 3)                         # rOBJ<- vBBBB
-    GET_VREG(a0, a3)                       #  a0 <- vCCCC (object)
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- pDvmDex
-    # is object null?
-    beqz      a0, .LOP_INSTANCE_OF_JUMBO_store        #  null obj, not an instance, store a0
-    FETCH(a1, 1)                           # r1<- aaaa (lo)
-    FETCH(a3, 2)                           # r3<- AAAA (hi)
-    LOAD_base_offDvmDex_pResClasses(a2, a2) #  a2 <- pDvmDex->pResClasses
-    sll     a3,a3,16
-    or      a3, a1, a3                     # a3<- AAAAaaaa
-
-    LOAD_eas2(a1, a2, a3)                  #  a1 <- resolved class
-    LOAD_base_offObject_clazz(a0, a0)      #  a0 <- obj->clazz
-    # have we resolved this before?
-    beqz      a1, .LOP_INSTANCE_OF_JUMBO_resolve      #  not resolved, do it now
-    b       .LOP_INSTANCE_OF_JUMBO_resolved           # resolved, continue
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_NEW_INSTANCE_JUMBO: /* 0x103 */
-/* File: mips/OP_NEW_INSTANCE_JUMBO.S */
-    /*
-     * Create a new instance of a class.
-     */
-    /* new-instance/jumbo vBBBB, class@AAAAAAAA */
-    FETCH(a0, 1)                            # a0<- aaaa (lo)DvmDex
-    FETCH(a1, 2)                            # a1<- AAAA (hi)BBB
-    LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
-    sll      a1,a1,16
-    or       a1, a0, a1                    # a1<- AAAAaaaa
-    LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved class
-#if defined(WITH_JIT)
-    EAS2(rBIX, a3, a1)                     #  rBIX <- &resolved_class
-#endif
-    EXPORT_PC()                            #  req'd for init, resolve, alloc
-    # already resolved?
-    beqz      a0, .LOP_NEW_INSTANCE_JUMBO_resolve      #  no, resolve it now
-.LOP_NEW_INSTANCE_JUMBO_resolved:                   #  a0=class
-    lbu       a1, offClassObject_status(a0) #  a1 <- ClassStatus enum
-    # has class been initialized?
-    li        t0, CLASS_INITIALIZED
-    move      rOBJ, a0                     #  save a0
-    bne       a1, t0, .LOP_NEW_INSTANCE_JUMBO_needinit #  no, init class now
-
-.LOP_NEW_INSTANCE_JUMBO_initialized:                #  a0=class
-    LOAD_base_offClassObject_accessFlags(a3, a0) #  a3 <- clazz->accessFlags
-    li        a1, ALLOC_DONT_TRACK         #  flags for alloc call
-    # a0=class
-    JAL(dvmAllocObject)                    #  v0 <- new object
-    FETCH(a3, 3)                           # a3<- BBBB
-#if defined(WITH_JIT)
-    /*
-     * The JIT needs the class to be fully resolved before it can
-     * include this instruction in a trace.
-     */
-    lhu       a1, offThread_subMode(rSELF)
-    beqz      v0, common_exceptionThrown   #  yes, handle the exception
-    and       a1, kSubModeJitTraceBuild    #  under construction?
-    bnez      a1, .LOP_NEW_INSTANCE_JUMBO_jitCheck
-#else
-    # failed?
-    beqz      v0, common_exceptionThrown   #  yes, handle the exception
-#endif
-    b         .LOP_NEW_INSTANCE_JUMBO_continue
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_NEW_ARRAY_JUMBO: /* 0x104 */
-/* File: mips/OP_NEW_ARRAY_JUMBO.S */
-    /*
-     * Allocate an array of objects, specified with the array class
-     * and a count.
-     *
-     * The verifier guarantees that this is an array class, so we don't
-     * check for it here.
-     */
-    /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */
-    FETCH(a2, 1)                           # a2<- aaaa (lo)
-    FETCH(a3, 2)                           # a3<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- vCCCC
-    sll     a3,a3,16                       #
-    or      a2, a2, a3                     # a2<- AAAAaaaa
-
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
-    GET_VREG(a1, a0)                       #  a1 <- vCCCC (array length)
-    LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
-    LOAD_eas2(a0, a3, a2)                  #  a0 <- resolved class
-    # check length
-    bltz      a1, common_errNegativeArraySize #  negative length, bail - len in a1
-    EXPORT_PC()                            #  req'd for resolve, alloc
-    # already resolved?
-    beqz      a0, .LOP_NEW_ARRAY_JUMBO_resolve      #  not resolved,
-    b         .LOP_NEW_ARRAY_JUMBO_finish
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */
-/* File: mips/OP_FILLED_NEW_ARRAY_JUMBO.S */
-    /*
-     * Create a new array with elements filled from registers.
-     *
-     * TODO: convert most of this into a common subroutine, shared with
-     *       OP_FILLED_NEW_ARRAY.S.
-     */
-     /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */
-
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
-    FETCH(a0, 1)                           # r0<- aaaa (lo)
-    FETCH(a1, 2)                           # r1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved class
-    GET_OPA(rOBJ)                          #  rOBJ <- AA or BA
-    EXPORT_PC()                            #  need for resolve and alloc
-    # already resolved?
-    bnez      a0, .LOP_FILLED_NEW_ARRAY_JUMBO_continue     #  yes, continue on
-    LOAD_rSELF_method(a3)                  #  a3 <- self->method
-    li        a2, 0                        #  a2 <- false
-    LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
-    JAL(dvmResolveClass)                   #  v0 <- call(clazz, ref)
-    move      a0, v0
-    # got null?
-    beqz      v0, common_exceptionThrown   #  yes, handle exception
-    b         .LOP_FILLED_NEW_ARRAY_JUMBO_continue
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_JUMBO: /* 0x106 */
-/* File: mips/OP_IGET_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field get.
-     *
-     * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
-     *      iget-char/jumbo, iget-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll     a2,a2,16
-    or      a1, a1, a2                     # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_JUMBO_resolved        # resolved, continue
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_WIDE_JUMBO: /* 0x107 */
-/* File: mips/OP_IGET_WIDE_JUMBO.S */
-    /*
-     * Jumbo 64-bit instance field get.
-     */
-    /* iget-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll    a2,a2,16
-    or     a1, a1, a2                      # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[CCCC], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_WIDE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_WIDE_JUMBO_resolved           # resolved, continue
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_OBJECT_JUMBO: /* 0x108 */
-/* File: mips/OP_IGET_OBJECT_JUMBO.S */
-/* File: mips/OP_IGET_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field get.
-     *
-     * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
-     *      iget-char/jumbo, iget-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll     a2,a2,16
-    or      a1, a1, a2                     # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_OBJECT_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_OBJECT_JUMBO_resolved        # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */
-/* File: mips/OP_IGET_BOOLEAN_JUMBO.S */
-/* File: mips/OP_IGET_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field get.
-     *
-     * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
-     *      iget-char/jumbo, iget-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll     a2,a2,16
-    or      a1, a1, a2                     # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_BOOLEAN_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_BOOLEAN_JUMBO_resolved        # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_BYTE_JUMBO: /* 0x10a */
-/* File: mips/OP_IGET_BYTE_JUMBO.S */
-/* File: mips/OP_IGET_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field get.
-     *
-     * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
-     *      iget-char/jumbo, iget-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll     a2,a2,16
-    or      a1, a1, a2                     # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_BYTE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_BYTE_JUMBO_resolved        # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_CHAR_JUMBO: /* 0x10b */
-/* File: mips/OP_IGET_CHAR_JUMBO.S */
-/* File: mips/OP_IGET_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field get.
-     *
-     * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
-     *      iget-char/jumbo, iget-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll     a2,a2,16
-    or      a1, a1, a2                     # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_CHAR_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_CHAR_JUMBO_resolved        # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_SHORT_JUMBO: /* 0x10c */
-/* File: mips/OP_IGET_SHORT_JUMBO.S */
-/* File: mips/OP_IGET_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field get.
-     *
-     * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
-     *      iget-char/jumbo, iget-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll     a2,a2,16
-    or      a1, a1, a2                     # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_SHORT_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_SHORT_JUMBO_resolved        # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_JUMBO: /* 0x10d */
-/* File: mips/OP_IPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field put.
-     *
-     * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
-     *      iput-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll       a2,a2,16
-    or        a1, a1, a2                   #  a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IPUT_JUMBO_resolved           # resolved, continue
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_WIDE_JUMBO: /* 0x10e */
-/* File: mips/OP_IPUT_WIDE_JUMBO.S */
-    /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll       a2,a2,16
-    or        a1, a1, a2                   # a1<- AAAAaaaa
-
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_WIDE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IPUT_WIDE_JUMBO_resolved           # resolved, continue
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_OBJECT_JUMBO: /* 0x10f */
-/* File: mips/OP_IPUT_OBJECT_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field put.
-     */
-    /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll      a1,a1,16
-    or       a1, a1, a2                    # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_OBJECT_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b         .LOP_IPUT_OBJECT_JUMBO_resolved
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */
-/* File: mips/OP_IPUT_BOOLEAN_JUMBO.S */
-/* File: mips/OP_IPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field put.
-     *
-     * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
-     *      iput-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll       a2,a2,16
-    or        a1, a1, a2                   #  a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_BOOLEAN_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IPUT_BOOLEAN_JUMBO_resolved           # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_BYTE_JUMBO: /* 0x111 */
-/* File: mips/OP_IPUT_BYTE_JUMBO.S */
-/* File: mips/OP_IPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field put.
-     *
-     * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
-     *      iput-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll       a2,a2,16
-    or        a1, a1, a2                   #  a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_BYTE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IPUT_BYTE_JUMBO_resolved           # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_CHAR_JUMBO: /* 0x112 */
-/* File: mips/OP_IPUT_CHAR_JUMBO.S */
-/* File: mips/OP_IPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field put.
-     *
-     * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
-     *      iput-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll       a2,a2,16
-    or        a1, a1, a2                   #  a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_CHAR_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IPUT_CHAR_JUMBO_resolved           # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_SHORT_JUMBO: /* 0x113 */
-/* File: mips/OP_IPUT_SHORT_JUMBO.S */
-/* File: mips/OP_IPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field put.
-     *
-     * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
-     *      iput-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll       a2,a2,16
-    or        a1, a1, a2                   #  a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_SHORT_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IPUT_SHORT_JUMBO_resolved           # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_JUMBO: /* 0x114 */
-/* File: mips/OP_SGET_JUMBO.S */
-     /*
-     * Jumbo 32-bit SGET handler.
-     *
-     * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
-     *      sget-char/jumbo, sget-short/jumbo
-     */
-     /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry !null?
-    bnez      a0, .LOP_SGET_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SGET_JUMBO_finish            # resume
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_WIDE_JUMBO: /* 0x115 */
-/* File: mips/OP_SGET_WIDE_JUMBO.S */
-    /*
-     * Jumbo 64-bit SGET handler.
-     */
-    /* sget-wide/jumbo vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(a2, a2) #  a2 <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                 # a1<- AAAAaaaa
-    LOAD_eas2(a0, a2, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_SGET_WIDE_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *
-     * Returns StaticField pointer in v0.
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  a0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-    b        .LOP_SGET_WIDE_JUMBO_finish            # resume
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_OBJECT_JUMBO: /* 0x116 */
-/* File: mips/OP_SGET_OBJECT_JUMBO.S */
-/* File: mips/OP_SGET_JUMBO.S */
-     /*
-     * Jumbo 32-bit SGET handler.
-     *
-     * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
-     *      sget-char/jumbo, sget-short/jumbo
-     */
-     /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry !null?
-    bnez      a0, .LOP_SGET_OBJECT_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SGET_OBJECT_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */
-/* File: mips/OP_SGET_BOOLEAN_JUMBO.S */
-/* File: mips/OP_SGET_JUMBO.S */
-     /*
-     * Jumbo 32-bit SGET handler.
-     *
-     * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
-     *      sget-char/jumbo, sget-short/jumbo
-     */
-     /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry !null?
-    bnez      a0, .LOP_SGET_BOOLEAN_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SGET_BOOLEAN_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_BYTE_JUMBO: /* 0x118 */
-/* File: mips/OP_SGET_BYTE_JUMBO.S */
-/* File: mips/OP_SGET_JUMBO.S */
-     /*
-     * Jumbo 32-bit SGET handler.
-     *
-     * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
-     *      sget-char/jumbo, sget-short/jumbo
-     */
-     /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry !null?
-    bnez      a0, .LOP_SGET_BYTE_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SGET_BYTE_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_CHAR_JUMBO: /* 0x119 */
-/* File: mips/OP_SGET_CHAR_JUMBO.S */
-/* File: mips/OP_SGET_JUMBO.S */
-     /*
-     * Jumbo 32-bit SGET handler.
-     *
-     * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
-     *      sget-char/jumbo, sget-short/jumbo
-     */
-     /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry !null?
-    bnez      a0, .LOP_SGET_CHAR_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SGET_CHAR_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_SHORT_JUMBO: /* 0x11a */
-/* File: mips/OP_SGET_SHORT_JUMBO.S */
-/* File: mips/OP_SGET_JUMBO.S */
-     /*
-     * Jumbo 32-bit SGET handler.
-     *
-     * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
-     *      sget-char/jumbo, sget-short/jumbo
-     */
-     /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry !null?
-    bnez      a0, .LOP_SGET_SHORT_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SGET_SHORT_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_JUMBO: /* 0x11b */
-/* File: mips/OP_SPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit SPUT handler.
-     *
-     * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
-     *      sput-short/jumbo
-     */
-    /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    bnez      a0, .LOP_SPUT_JUMBO_finish       #  is resolved entry null?
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() may throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  success? no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SPUT_JUMBO_finish            # resume
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_WIDE_JUMBO: /* 0x11c */
-/* File: mips/OP_SPUT_WIDE_JUMBO.S */
-    /*
-     * Jumbo 64-bit SPUT handler.
-     */
-    /* sput-wide/jumbo vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll     a2,a2,16
-    or      a1, a1, a2                    # a1<- AAAAaaaa
-    FETCH(rOBJ, 3)                        # rOBJ<- BBBB    solved StaticField ptr
-    EAS2(rOBJ, rFP, t0)                    #  rOBJ<- &fp[BBBB]
-    # is resolved entry null?
-    beqz      a2, .LOP_SPUT_WIDE_JUMBO_resolve      #  yes, do resolve
-.LOP_SPUT_WIDE_JUMBO_finish:                        #  field ptr in a2, BBBB in rOBJ
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- vBBBB/vBBBB+1
-    GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
-    .if 0
-    addu    a2, offStaticField_value       #  a2<- pointer to data
-    JAL(dvmQuasiAtomicSwap64Sync)          #  stores a0/a1 into addr a2
-    .else
-    STORE64_off(a0, a1, a2, offStaticField_value) #  field <- vBBBB/vBBBB+1
-    .endif
-    GOTO_OPCODE(rBIX)                      #  jump to next instruction
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_OBJECT_JUMBO: /* 0x11d */
-/* File: mips/OP_SPUT_OBJECT_JUMBO.S */
-    /*
-     * Jumbo 32-bit SPUT handler for objects
-     */
-    /* sput-object/jumbo vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll     a1,a1,16
-    or      a1,a0,a1                       # a1<- AAAAaaaa
-
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    bnez      a0, .LOP_SPUT_OBJECT_JUMBO_finish       #  is resolved entry null?
-
-    /* Continuation if the field has not yet been resolved.
-     * a1:  BBBB field ref
-     * rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() may throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  success? no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b         .LOP_SPUT_OBJECT_JUMBO_finish           #  resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */
-/* File: mips/OP_SPUT_BOOLEAN_JUMBO.S */
-/* File: mips/OP_SPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit SPUT handler.
-     *
-     * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
-     *      sput-short/jumbo
-     */
-    /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    bnez      a0, .LOP_SPUT_BOOLEAN_JUMBO_finish       #  is resolved entry null?
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() may throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  success? no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SPUT_BOOLEAN_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_BYTE_JUMBO: /* 0x11f */
-/* File: mips/OP_SPUT_BYTE_JUMBO.S */
-/* File: mips/OP_SPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit SPUT handler.
-     *
-     * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
-     *      sput-short/jumbo
-     */
-    /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    bnez      a0, .LOP_SPUT_BYTE_JUMBO_finish       #  is resolved entry null?
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() may throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  success? no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SPUT_BYTE_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_CHAR_JUMBO: /* 0x120 */
-/* File: mips/OP_SPUT_CHAR_JUMBO.S */
-/* File: mips/OP_SPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit SPUT handler.
-     *
-     * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
-     *      sput-short/jumbo
-     */
-    /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    bnez      a0, .LOP_SPUT_CHAR_JUMBO_finish       #  is resolved entry null?
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() may throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  success? no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SPUT_CHAR_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_SHORT_JUMBO: /* 0x121 */
-/* File: mips/OP_SPUT_SHORT_JUMBO.S */
-/* File: mips/OP_SPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit SPUT handler.
-     *
-     * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
-     *      sput-short/jumbo
-     */
-    /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    bnez      a0, .LOP_SPUT_SHORT_JUMBO_finish       #  is resolved entry null?
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() may throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  success? no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SPUT_SHORT_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */
-/* File: mips/OP_INVOKE_VIRTUAL_JUMBO.S */
-    /*
-     * Handle a virtual method call.
-     */
-     /* invoke-virtual/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
-    sll     a1,a1,16
-    or      a1, a0, a1                     # a1<- AAAAaaaa
-    LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved baseMethod
-    EXPORT_PC()                            #  must export for invoke
-    # already resolved?
-    bnez      a0, .LOP_INVOKE_VIRTUAL_JUMBO_continue     #  yes, continue on
-
-    LOAD_rSELF_method(a3)                  #  a3 <- self->method
-    LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
-    li        a2, METHOD_VIRTUAL           #  resolver method type
-    JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
-    move      a0, v0
-    # got null?
-    bnez      v0, .LOP_INVOKE_VIRTUAL_JUMBO_continue     #  no, continue
-    b         common_exceptionThrown       #  yes, handle exception
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_INVOKE_SUPER_JUMBO: /* 0x123 */
-/* File: mips/OP_INVOKE_SUPER_JUMBO.S */
-    /*
-     * Handle a "super" method call.
-    */
-    /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
-    FETCH(t0, 4)                           # t0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    GET_VREG(rOBJ, t0)                     #  rOBJ <- "this" ptr
-    LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved baseMethod
-    # null "this"?
-    LOAD_rSELF_method(t1)                  #  t1 <- current method
-    beqz      rOBJ, common_errNullObject   #  null "this", throw exception
-    # cmp a0, 0; already resolved?
-    LOAD_base_offMethod_clazz(rBIX, t1)    #  rBIX <- method->clazz
-    EXPORT_PC()                            #  must export for invoke
-    bnez      a0, .LOP_INVOKE_SUPER_JUMBO_continue     #  resolved, continue on
-
-    move      a0, rBIX                     #  a0 <- method->clazz
-    li        a2, METHOD_VIRTUAL           #  resolver method type
-    JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
-    move      a0, v0
-    # got null?
-    beqz      v0, common_exceptionThrown   #  yes, handle exception
-    b         .LOP_INVOKE_SUPER_JUMBO_continue
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */
-/* File: mips/OP_INVOKE_DIRECT_JUMBO.S */
-    /*
-     * Handle a direct method call.
-     *
-     * (We could defer the "is 'this' pointer null" test to the common
-     * method invocation code, and use a flag to indicate that static
-     * calls don't count.  If we do this as part of copying the arguments
-     * out we could avoiding loading the first arg twice.)
-     *
-     */
-     /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
-    sll     a1,a1,16
-    or      a1, a0, a1                     # a1<- AAAAaaaa
-    FETCH(rBIX, 4)                         #  rBIX <- GFED or CCCC
-    LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved methodToCall
-    .if (!0)
-    and       rBIX, rBIX, 15               #  rBIX <- D (or stays CCCC)
-    .endif
-    EXPORT_PC()                            #  must export for invoke
-    GET_VREG(rOBJ, rBIX)                   #  rOBJ <- "this" ptr
-    # already resolved?
-    bnez      a0, 1f                       #  resolved, call the function
-
-    lw        a3, offThread_method(rSELF)  #  a3 <- self->method
-    LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
-    li        a2, METHOD_DIRECT            #  resolver method type
-    JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
-    move      a0, v0
-    # got null?
-    beqz      v0, common_exceptionThrown   #  yes, handle exception
-
-1:
-    bnez      rOBJ, common_invokeMethodJumbo #  a0=method, rOBJ="this"
-    b         common_errNullObject         #  yes, throw exception
-
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_INVOKE_STATIC_JUMBO: /* 0x125 */
-/* File: mips/OP_INVOKE_STATIC_JUMBO.S */
-    /*
-     * Handle a static method call.
-     */
-     /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
-    sll     a1,a1,16
-    or      a1, a0, a1                     # r1<- AAAAaaaa
-    li      rOBJ, 0                       #  null "this" in delay slot
-    LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved methodToCall
-#if defined(WITH_JIT)
-    EAS2(rBIX, a3, a1)                     #  rBIX<- &resolved_metherToCall
-#endif
-    EXPORT_PC()                            #  must export for invoke
-    # already resolved?
-    bnez      a0, common_invokeMethodJumboNoThis #  (a0 = method)
-    b         .LOP_INVOKE_STATIC_JUMBO_resolve
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */
-/* File: mips/OP_INVOKE_INTERFACE_JUMBO.S */
-    /*
-     * Handle an interface method call.
-     */
-    /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
-    FETCH(a2, 4)                           # a2<- CCCC
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    EXPORT_PC()                            #  must export for invoke
-    sll       a1,a1,16
-    or        a1, a0, a1                   #  a1<- AAAAaaaa
-    GET_VREG(rOBJ, a2)                     #  rOBJ <- first arg ("this")
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- methodClassDex
-    LOAD_rSELF_method(a2)                  #  a2 <- method
-    # null obj?
-    beqz      rOBJ, common_errNullObject   #  yes, fail
-    LOAD_base_offObject_clazz(a0, rOBJ)      #  a0 <- thisPtr->clazz
-    JAL(dvmFindInterfaceMethodInCache)     #  v0 <- call(class, ref, method, dex)
-    move      a0, v0
-    # failed?
-    beqz      v0, common_exceptionThrown   #  yes, handle exception
-    b         common_invokeMethodJumbo #  (a0=method, rOBJ="this")
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_27FF: /* 0x127 */
-/* File: mips/OP_UNUSED_27FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_28FF: /* 0x128 */
-/* File: mips/OP_UNUSED_28FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_29FF: /* 0x129 */
-/* File: mips/OP_UNUSED_29FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_2AFF: /* 0x12a */
-/* File: mips/OP_UNUSED_2AFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_2BFF: /* 0x12b */
-/* File: mips/OP_UNUSED_2BFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_2CFF: /* 0x12c */
-/* File: mips/OP_UNUSED_2CFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_2DFF: /* 0x12d */
-/* File: mips/OP_UNUSED_2DFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_2EFF: /* 0x12e */
-/* File: mips/OP_UNUSED_2EFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_2FFF: /* 0x12f */
-/* File: mips/OP_UNUSED_2FFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_30FF: /* 0x130 */
-/* File: mips/OP_UNUSED_30FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_31FF: /* 0x131 */
-/* File: mips/OP_UNUSED_31FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_32FF: /* 0x132 */
-/* File: mips/OP_UNUSED_32FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_33FF: /* 0x133 */
-/* File: mips/OP_UNUSED_33FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_34FF: /* 0x134 */
-/* File: mips/OP_UNUSED_34FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_35FF: /* 0x135 */
-/* File: mips/OP_UNUSED_35FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_36FF: /* 0x136 */
-/* File: mips/OP_UNUSED_36FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_37FF: /* 0x137 */
-/* File: mips/OP_UNUSED_37FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_38FF: /* 0x138 */
-/* File: mips/OP_UNUSED_38FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_39FF: /* 0x139 */
-/* File: mips/OP_UNUSED_39FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_3AFF: /* 0x13a */
-/* File: mips/OP_UNUSED_3AFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_3BFF: /* 0x13b */
-/* File: mips/OP_UNUSED_3BFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_3CFF: /* 0x13c */
-/* File: mips/OP_UNUSED_3CFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_3DFF: /* 0x13d */
-/* File: mips/OP_UNUSED_3DFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_3EFF: /* 0x13e */
-/* File: mips/OP_UNUSED_3EFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_3FFF: /* 0x13f */
-/* File: mips/OP_UNUSED_3FFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_40FF: /* 0x140 */
-/* File: mips/OP_UNUSED_40FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_41FF: /* 0x141 */
-/* File: mips/OP_UNUSED_41FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_42FF: /* 0x142 */
-/* File: mips/OP_UNUSED_42FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_43FF: /* 0x143 */
-/* File: mips/OP_UNUSED_43FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_44FF: /* 0x144 */
-/* File: mips/OP_UNUSED_44FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_45FF: /* 0x145 */
-/* File: mips/OP_UNUSED_45FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_46FF: /* 0x146 */
-/* File: mips/OP_UNUSED_46FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_47FF: /* 0x147 */
-/* File: mips/OP_UNUSED_47FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_48FF: /* 0x148 */
-/* File: mips/OP_UNUSED_48FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_49FF: /* 0x149 */
-/* File: mips/OP_UNUSED_49FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_4AFF: /* 0x14a */
-/* File: mips/OP_UNUSED_4AFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_4BFF: /* 0x14b */
-/* File: mips/OP_UNUSED_4BFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_4CFF: /* 0x14c */
-/* File: mips/OP_UNUSED_4CFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_4DFF: /* 0x14d */
-/* File: mips/OP_UNUSED_4DFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_4EFF: /* 0x14e */
-/* File: mips/OP_UNUSED_4EFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_4FFF: /* 0x14f */
-/* File: mips/OP_UNUSED_4FFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_50FF: /* 0x150 */
-/* File: mips/OP_UNUSED_50FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_51FF: /* 0x151 */
-/* File: mips/OP_UNUSED_51FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_52FF: /* 0x152 */
-/* File: mips/OP_UNUSED_52FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_53FF: /* 0x153 */
-/* File: mips/OP_UNUSED_53FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_54FF: /* 0x154 */
-/* File: mips/OP_UNUSED_54FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_55FF: /* 0x155 */
-/* File: mips/OP_UNUSED_55FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_56FF: /* 0x156 */
-/* File: mips/OP_UNUSED_56FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_57FF: /* 0x157 */
-/* File: mips/OP_UNUSED_57FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_58FF: /* 0x158 */
-/* File: mips/OP_UNUSED_58FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_59FF: /* 0x159 */
-/* File: mips/OP_UNUSED_59FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_5AFF: /* 0x15a */
-/* File: mips/OP_UNUSED_5AFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_5BFF: /* 0x15b */
-/* File: mips/OP_UNUSED_5BFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_5CFF: /* 0x15c */
-/* File: mips/OP_UNUSED_5CFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_5DFF: /* 0x15d */
-/* File: mips/OP_UNUSED_5DFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_5EFF: /* 0x15e */
-/* File: mips/OP_UNUSED_5EFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_5FFF: /* 0x15f */
-/* File: mips/OP_UNUSED_5FFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_60FF: /* 0x160 */
-/* File: mips/OP_UNUSED_60FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_61FF: /* 0x161 */
-/* File: mips/OP_UNUSED_61FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_62FF: /* 0x162 */
-/* File: mips/OP_UNUSED_62FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_63FF: /* 0x163 */
-/* File: mips/OP_UNUSED_63FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_64FF: /* 0x164 */
-/* File: mips/OP_UNUSED_64FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_65FF: /* 0x165 */
-/* File: mips/OP_UNUSED_65FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_66FF: /* 0x166 */
-/* File: mips/OP_UNUSED_66FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_67FF: /* 0x167 */
-/* File: mips/OP_UNUSED_67FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_68FF: /* 0x168 */
-/* File: mips/OP_UNUSED_68FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_69FF: /* 0x169 */
-/* File: mips/OP_UNUSED_69FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_6AFF: /* 0x16a */
-/* File: mips/OP_UNUSED_6AFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_6BFF: /* 0x16b */
-/* File: mips/OP_UNUSED_6BFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_6CFF: /* 0x16c */
-/* File: mips/OP_UNUSED_6CFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_6DFF: /* 0x16d */
-/* File: mips/OP_UNUSED_6DFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_6EFF: /* 0x16e */
-/* File: mips/OP_UNUSED_6EFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_6FFF: /* 0x16f */
-/* File: mips/OP_UNUSED_6FFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_70FF: /* 0x170 */
-/* File: mips/OP_UNUSED_70FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_71FF: /* 0x171 */
-/* File: mips/OP_UNUSED_71FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_72FF: /* 0x172 */
-/* File: mips/OP_UNUSED_72FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_73FF: /* 0x173 */
-/* File: mips/OP_UNUSED_73FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_74FF: /* 0x174 */
-/* File: mips/OP_UNUSED_74FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_75FF: /* 0x175 */
-/* File: mips/OP_UNUSED_75FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_76FF: /* 0x176 */
-/* File: mips/OP_UNUSED_76FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_77FF: /* 0x177 */
-/* File: mips/OP_UNUSED_77FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_78FF: /* 0x178 */
-/* File: mips/OP_UNUSED_78FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_79FF: /* 0x179 */
-/* File: mips/OP_UNUSED_79FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_7AFF: /* 0x17a */
-/* File: mips/OP_UNUSED_7AFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_7BFF: /* 0x17b */
-/* File: mips/OP_UNUSED_7BFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_7CFF: /* 0x17c */
-/* File: mips/OP_UNUSED_7CFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_7DFF: /* 0x17d */
-/* File: mips/OP_UNUSED_7DFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_7EFF: /* 0x17e */
-/* File: mips/OP_UNUSED_7EFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_7FFF: /* 0x17f */
-/* File: mips/OP_UNUSED_7FFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_80FF: /* 0x180 */
-/* File: mips/OP_UNUSED_80FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_81FF: /* 0x181 */
-/* File: mips/OP_UNUSED_81FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_82FF: /* 0x182 */
-/* File: mips/OP_UNUSED_82FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_83FF: /* 0x183 */
-/* File: mips/OP_UNUSED_83FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_84FF: /* 0x184 */
-/* File: mips/OP_UNUSED_84FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_85FF: /* 0x185 */
-/* File: mips/OP_UNUSED_85FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_86FF: /* 0x186 */
-/* File: mips/OP_UNUSED_86FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_87FF: /* 0x187 */
-/* File: mips/OP_UNUSED_87FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_88FF: /* 0x188 */
-/* File: mips/OP_UNUSED_88FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_89FF: /* 0x189 */
-/* File: mips/OP_UNUSED_89FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_8AFF: /* 0x18a */
-/* File: mips/OP_UNUSED_8AFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_8BFF: /* 0x18b */
-/* File: mips/OP_UNUSED_8BFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_8CFF: /* 0x18c */
-/* File: mips/OP_UNUSED_8CFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_8DFF: /* 0x18d */
-/* File: mips/OP_UNUSED_8DFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_8EFF: /* 0x18e */
-/* File: mips/OP_UNUSED_8EFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_8FFF: /* 0x18f */
-/* File: mips/OP_UNUSED_8FFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_90FF: /* 0x190 */
-/* File: mips/OP_UNUSED_90FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_91FF: /* 0x191 */
-/* File: mips/OP_UNUSED_91FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_92FF: /* 0x192 */
-/* File: mips/OP_UNUSED_92FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_93FF: /* 0x193 */
-/* File: mips/OP_UNUSED_93FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_94FF: /* 0x194 */
-/* File: mips/OP_UNUSED_94FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_95FF: /* 0x195 */
-/* File: mips/OP_UNUSED_95FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_96FF: /* 0x196 */
-/* File: mips/OP_UNUSED_96FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_97FF: /* 0x197 */
-/* File: mips/OP_UNUSED_97FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_98FF: /* 0x198 */
-/* File: mips/OP_UNUSED_98FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_99FF: /* 0x199 */
-/* File: mips/OP_UNUSED_99FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_9AFF: /* 0x19a */
-/* File: mips/OP_UNUSED_9AFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_9BFF: /* 0x19b */
-/* File: mips/OP_UNUSED_9BFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_9CFF: /* 0x19c */
-/* File: mips/OP_UNUSED_9CFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_9DFF: /* 0x19d */
-/* File: mips/OP_UNUSED_9DFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_9EFF: /* 0x19e */
-/* File: mips/OP_UNUSED_9EFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_9FFF: /* 0x19f */
-/* File: mips/OP_UNUSED_9FFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A0FF: /* 0x1a0 */
-/* File: mips/OP_UNUSED_A0FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A1FF: /* 0x1a1 */
-/* File: mips/OP_UNUSED_A1FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A2FF: /* 0x1a2 */
-/* File: mips/OP_UNUSED_A2FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A3FF: /* 0x1a3 */
-/* File: mips/OP_UNUSED_A3FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A4FF: /* 0x1a4 */
-/* File: mips/OP_UNUSED_A4FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A5FF: /* 0x1a5 */
-/* File: mips/OP_UNUSED_A5FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A6FF: /* 0x1a6 */
-/* File: mips/OP_UNUSED_A6FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A7FF: /* 0x1a7 */
-/* File: mips/OP_UNUSED_A7FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A8FF: /* 0x1a8 */
-/* File: mips/OP_UNUSED_A8FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_A9FF: /* 0x1a9 */
-/* File: mips/OP_UNUSED_A9FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_AAFF: /* 0x1aa */
-/* File: mips/OP_UNUSED_AAFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_ABFF: /* 0x1ab */
-/* File: mips/OP_UNUSED_ABFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_ACFF: /* 0x1ac */
-/* File: mips/OP_UNUSED_ACFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_ADFF: /* 0x1ad */
-/* File: mips/OP_UNUSED_ADFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_AEFF: /* 0x1ae */
-/* File: mips/OP_UNUSED_AEFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_AFFF: /* 0x1af */
-/* File: mips/OP_UNUSED_AFFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B0FF: /* 0x1b0 */
-/* File: mips/OP_UNUSED_B0FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B1FF: /* 0x1b1 */
-/* File: mips/OP_UNUSED_B1FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B2FF: /* 0x1b2 */
-/* File: mips/OP_UNUSED_B2FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B3FF: /* 0x1b3 */
-/* File: mips/OP_UNUSED_B3FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B4FF: /* 0x1b4 */
-/* File: mips/OP_UNUSED_B4FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B5FF: /* 0x1b5 */
-/* File: mips/OP_UNUSED_B5FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B6FF: /* 0x1b6 */
-/* File: mips/OP_UNUSED_B6FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B7FF: /* 0x1b7 */
-/* File: mips/OP_UNUSED_B7FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B8FF: /* 0x1b8 */
-/* File: mips/OP_UNUSED_B8FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_B9FF: /* 0x1b9 */
-/* File: mips/OP_UNUSED_B9FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_BAFF: /* 0x1ba */
-/* File: mips/OP_UNUSED_BAFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_BBFF: /* 0x1bb */
-/* File: mips/OP_UNUSED_BBFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_BCFF: /* 0x1bc */
-/* File: mips/OP_UNUSED_BCFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_BDFF: /* 0x1bd */
-/* File: mips/OP_UNUSED_BDFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_BEFF: /* 0x1be */
-/* File: mips/OP_UNUSED_BEFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_BFFF: /* 0x1bf */
-/* File: mips/OP_UNUSED_BFFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C0FF: /* 0x1c0 */
-/* File: mips/OP_UNUSED_C0FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C1FF: /* 0x1c1 */
-/* File: mips/OP_UNUSED_C1FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C2FF: /* 0x1c2 */
-/* File: mips/OP_UNUSED_C2FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C3FF: /* 0x1c3 */
-/* File: mips/OP_UNUSED_C3FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C4FF: /* 0x1c4 */
-/* File: mips/OP_UNUSED_C4FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C5FF: /* 0x1c5 */
-/* File: mips/OP_UNUSED_C5FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C6FF: /* 0x1c6 */
-/* File: mips/OP_UNUSED_C6FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C7FF: /* 0x1c7 */
-/* File: mips/OP_UNUSED_C7FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C8FF: /* 0x1c8 */
-/* File: mips/OP_UNUSED_C8FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_C9FF: /* 0x1c9 */
-/* File: mips/OP_UNUSED_C9FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_CAFF: /* 0x1ca */
-/* File: mips/OP_UNUSED_CAFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_CBFF: /* 0x1cb */
-/* File: mips/OP_UNUSED_CBFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_CCFF: /* 0x1cc */
-/* File: mips/OP_UNUSED_CCFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_CDFF: /* 0x1cd */
-/* File: mips/OP_UNUSED_CDFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_CEFF: /* 0x1ce */
-/* File: mips/OP_UNUSED_CEFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_CFFF: /* 0x1cf */
-/* File: mips/OP_UNUSED_CFFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D0FF: /* 0x1d0 */
-/* File: mips/OP_UNUSED_D0FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D1FF: /* 0x1d1 */
-/* File: mips/OP_UNUSED_D1FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D2FF: /* 0x1d2 */
-/* File: mips/OP_UNUSED_D2FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D3FF: /* 0x1d3 */
-/* File: mips/OP_UNUSED_D3FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D4FF: /* 0x1d4 */
-/* File: mips/OP_UNUSED_D4FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D5FF: /* 0x1d5 */
-/* File: mips/OP_UNUSED_D5FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D6FF: /* 0x1d6 */
-/* File: mips/OP_UNUSED_D6FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D7FF: /* 0x1d7 */
-/* File: mips/OP_UNUSED_D7FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D8FF: /* 0x1d8 */
-/* File: mips/OP_UNUSED_D8FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_D9FF: /* 0x1d9 */
-/* File: mips/OP_UNUSED_D9FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_DAFF: /* 0x1da */
-/* File: mips/OP_UNUSED_DAFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_DBFF: /* 0x1db */
-/* File: mips/OP_UNUSED_DBFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_DCFF: /* 0x1dc */
-/* File: mips/OP_UNUSED_DCFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_DDFF: /* 0x1dd */
-/* File: mips/OP_UNUSED_DDFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_DEFF: /* 0x1de */
-/* File: mips/OP_UNUSED_DEFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_DFFF: /* 0x1df */
-/* File: mips/OP_UNUSED_DFFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E0FF: /* 0x1e0 */
-/* File: mips/OP_UNUSED_E0FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E1FF: /* 0x1e1 */
-/* File: mips/OP_UNUSED_E1FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E2FF: /* 0x1e2 */
-/* File: mips/OP_UNUSED_E2FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E3FF: /* 0x1e3 */
-/* File: mips/OP_UNUSED_E3FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E4FF: /* 0x1e4 */
-/* File: mips/OP_UNUSED_E4FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E5FF: /* 0x1e5 */
-/* File: mips/OP_UNUSED_E5FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E6FF: /* 0x1e6 */
-/* File: mips/OP_UNUSED_E6FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E7FF: /* 0x1e7 */
-/* File: mips/OP_UNUSED_E7FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E8FF: /* 0x1e8 */
-/* File: mips/OP_UNUSED_E8FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_E9FF: /* 0x1e9 */
-/* File: mips/OP_UNUSED_E9FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_EAFF: /* 0x1ea */
-/* File: mips/OP_UNUSED_EAFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_EBFF: /* 0x1eb */
-/* File: mips/OP_UNUSED_EBFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_ECFF: /* 0x1ec */
-/* File: mips/OP_UNUSED_ECFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_EDFF: /* 0x1ed */
-/* File: mips/OP_UNUSED_EDFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_EEFF: /* 0x1ee */
-/* File: mips/OP_UNUSED_EEFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_EFFF: /* 0x1ef */
-/* File: mips/OP_UNUSED_EFFF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_F0FF: /* 0x1f0 */
-/* File: mips/OP_UNUSED_F0FF.S */
-/* File: mips/unused.S */
-    BAL(common_abort)
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_UNUSED_F1FF: /* 0x1f1 */
-/* File: mips/OP_UNUSED_F1FF.S */
+.L_OP_UNUSED_FF: /* 0xff */
+/* File: mips/OP_UNUSED_FF.S */
 /* File: mips/unused.S */
     BAL(common_abort)
 
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */
-/* File: mips/OP_INVOKE_OBJECT_INIT_JUMBO.S */
-/* File: mips/OP_INVOKE_OBJECT_INIT_RANGE.S */
-    /*
-     * Invoke Object.<init> on an object.  In practice we know that
-     * Object's nullary constructor doesn't do anything, so we just
-     * skip it unless a debugger is active.
-     */
-    FETCH(a1, 4)                  # a1<- CCCC
-    GET_VREG(a0, a1)                    # a0<- "this" ptr
-    # check for NULL
-    beqz    a0, common_errNullObject    # export PC and throw NPE
-    LOAD_base_offObject_clazz(a1, a0)   # a1<- obj->clazz
-    LOAD_base_offClassObject_accessFlags(a2, a1) # a2<- clazz->accessFlags
-    and     a2, CLASS_ISFINALIZABLE     # is this class finalizable?
-    beqz    a2, .LOP_INVOKE_OBJECT_INIT_JUMBO_finish      # no, go
-
-.LOP_INVOKE_OBJECT_INIT_JUMBO_setFinal:
-    EXPORT_PC()                         # can throw
-    JAL(dvmSetFinalizable)              # call dvmSetFinalizable(obj)
-    LOAD_offThread_exception(a0, rSELF)	# a0<- self->exception
-    # exception pending?
-    bnez    a0, common_exceptionThrown  # yes, handle it
-
-.LOP_INVOKE_OBJECT_INIT_JUMBO_finish:
-    lhu     a1, offThread_subMode(rSELF)
-    and     a1, kSubModeDebuggerActive  # debugger active?
-    bnez    a1, .LOP_INVOKE_OBJECT_INIT_JUMBO_debugger    # Yes - skip optimization
-    FETCH_ADVANCE_INST(4+1)       # advance to next instr, load rINST
-    GET_INST_OPCODE(t0)                 # t0<- opcode from rINST
-    GOTO_OPCODE(t0)                     # execute it
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */
-/* File: mips/OP_IGET_VOLATILE_JUMBO.S */
-/* File: mips/OP_IGET_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field get.
-     *
-     * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
-     *      iget-char/jumbo, iget-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll     a2,a2,16
-    or      a1, a1, a2                     # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_VOLATILE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_VOLATILE_JUMBO_resolved        # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */
-/* File: mips/OP_IGET_WIDE_VOLATILE_JUMBO.S */
-/* File: mips/OP_IGET_WIDE_JUMBO.S */
-    /*
-     * Jumbo 64-bit instance field get.
-     */
-    /* iget-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll    a2,a2,16
-    or     a1, a1, a2                      # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[CCCC], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_WIDE_VOLATILE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_WIDE_VOLATILE_JUMBO_resolved           # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */
-/* File: mips/OP_IGET_OBJECT_VOLATILE_JUMBO.S */
-/* File: mips/OP_IGET_OBJECT_JUMBO.S */
-/* File: mips/OP_IGET_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field get.
-     *
-     * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
-     *      iget-char/jumbo, iget-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll     a2,a2,16
-    or      a1, a1, a2                     # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IGET_OBJECT_VOLATILE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IGET_OBJECT_VOLATILE_JUMBO_resolved        # resolved, continue
-
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */
-/* File: mips/OP_IPUT_VOLATILE_JUMBO.S */
-/* File: mips/OP_IPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field put.
-     *
-     * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
-     *      iput-short/jumbo
-     */
-    /* exop vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll       a2,a2,16
-    or        a1, a1, a2                   #  a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_VOLATILE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IPUT_VOLATILE_JUMBO_resolved           # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */
-/* File: mips/OP_IPUT_WIDE_VOLATILE_JUMBO.S */
-/* File: mips/OP_IPUT_WIDE_JUMBO.S */
-    /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll       a2,a2,16
-    or        a1, a1, a2                   # a1<- AAAAaaaa
-
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_WIDE_VOLATILE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b       .LOP_IPUT_WIDE_VOLATILE_JUMBO_resolved           # resolved, continue
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */
-/* File: mips/OP_IPUT_OBJECT_VOLATILE_JUMBO.S */
-/* File: mips/OP_IPUT_OBJECT_JUMBO.S */
-    /*
-     * Jumbo 32-bit instance field put.
-     */
-    /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    FETCH(a0, 4)                           # a0<- CCCC
-    LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
-    sll      a1,a1,16
-    or       a1, a1, a2                    # a1<- AAAAaaaa
-    LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
-    GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
-    LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_IPUT_OBJECT_VOLATILE_JUMBO_finish       #  no, already resolved
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
-    b         .LOP_IPUT_OBJECT_VOLATILE_JUMBO_resolved
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */
-/* File: mips/OP_SGET_VOLATILE_JUMBO.S */
-/* File: mips/OP_SGET_JUMBO.S */
-     /*
-     * Jumbo 32-bit SGET handler.
-     *
-     * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
-     *      sget-char/jumbo, sget-short/jumbo
-     */
-     /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry !null?
-    bnez      a0, .LOP_SGET_VOLATILE_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SGET_VOLATILE_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */
-/* File: mips/OP_SGET_WIDE_VOLATILE_JUMBO.S */
-/* File: mips/OP_SGET_WIDE_JUMBO.S */
-    /*
-     * Jumbo 64-bit SGET handler.
-     */
-    /* sget-wide/jumbo vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(a2, a2) #  a2 <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                 # a1<- AAAAaaaa
-    LOAD_eas2(a0, a2, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry null?
-    bnez      a0, .LOP_SGET_WIDE_VOLATILE_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *
-     * Returns StaticField pointer in v0.
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  a0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-    b        .LOP_SGET_WIDE_VOLATILE_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */
-/* File: mips/OP_SGET_OBJECT_VOLATILE_JUMBO.S */
-/* File: mips/OP_SGET_OBJECT_JUMBO.S */
-/* File: mips/OP_SGET_JUMBO.S */
-     /*
-     * Jumbo 32-bit SGET handler.
-     *
-     * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
-     *      sget-char/jumbo, sget-short/jumbo
-     */
-     /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    # is resolved entry !null?
-    bnez      a0, .LOP_SGET_OBJECT_VOLATILE_JUMBO_finish
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    # success?
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SGET_OBJECT_VOLATILE_JUMBO_finish            # resume
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */
-/* File: mips/OP_SPUT_VOLATILE_JUMBO.S */
-/* File: mips/OP_SPUT_JUMBO.S */
-    /*
-     * Jumbo 32-bit SPUT handler.
-     *
-     * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
-     *      sput-short/jumbo
-     */
-    /* exop vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll       a1,a1,16
-    or        a1, a0, a1                   # a1<- AAAAaaaa
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    bnez      a0, .LOP_SPUT_VOLATILE_JUMBO_finish       #  is resolved entry null?
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() may throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  success? no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b        .LOP_SPUT_VOLATILE_JUMBO_finish            # resume
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */
-/* File: mips/OP_SPUT_WIDE_VOLATILE_JUMBO.S */
-/* File: mips/OP_SPUT_WIDE_JUMBO.S */
-    /*
-     * Jumbo 64-bit SPUT handler.
-     */
-    /* sput-wide/jumbo vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll     a2,a2,16
-    or      a1, a1, a2                    # a1<- AAAAaaaa
-    FETCH(rOBJ, 3)                        # rOBJ<- BBBB    solved StaticField ptr
-    EAS2(rOBJ, rFP, t0)                    #  rOBJ<- &fp[BBBB]
-    # is resolved entry null?
-    beqz      a2, .LOP_SPUT_WIDE_VOLATILE_JUMBO_resolve      #  yes, do resolve
-.LOP_SPUT_WIDE_VOLATILE_JUMBO_finish:                        #  field ptr in a2, BBBB in rOBJ
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- vBBBB/vBBBB+1
-    GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
-    .if 1
-    addu    a2, offStaticField_value       #  a2<- pointer to data
-    JAL(dvmQuasiAtomicSwap64Sync)          #  stores a0/a1 into addr a2
-    .else
-    STORE64_off(a0, a1, a2, offStaticField_value) #  field <- vBBBB/vBBBB+1
-    .endif
-    GOTO_OPCODE(rBIX)                      #  jump to next instruction
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */
-/* File: mips/OP_SPUT_OBJECT_VOLATILE_JUMBO.S */
-/* File: mips/OP_SPUT_OBJECT_JUMBO.S */
-    /*
-     * Jumbo 32-bit SPUT handler for objects
-     */
-    /* sput-object/jumbo vBBBB, field@AAAAAAAA */
-    LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
-    FETCH(a0, 1)                           # a0<- aaaa (lo)
-    FETCH(a1, 2)                           # a1<- AAAA (hi)
-    LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
-    sll     a1,a1,16
-    or      a1,a0,a1                       # a1<- AAAAaaaa
-
-    LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
-    bnez      a0, .LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish       #  is resolved entry null?
-
-    /* Continuation if the field has not yet been resolved.
-     * a1:  BBBB field ref
-     * rBIX: dvmDex->pResFields
-     */
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() may throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  success? no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    b         .LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish           #  resume
-
-
-
-/* ------------------------------ */
-    .balign 128
-.L_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */
-/* File: mips/OP_THROW_VERIFICATION_ERROR_JUMBO.S */
-    /*
-     * Handle a jumbo throw-verification-error instruction.  This throws an
-     * exception for an error discovered during verification.  The
-     * exception is indicated by BBBB, with some detail provided by AAAAAAAA.
-     */
-     /* exop BBBB, Class@AAAAAAAA */
-    FETCH(a1, 1)                           # a1<- aaaa (lo)
-    FETCH(a2, 2)                           # a2<- AAAA (hi)
-    LOAD_rSELF_method(a0)                  #  a0 <- self->method
-    sll    a2,a2,16
-    or     a2, a1, a2                      # a2<- AAAAaaaa
-    EXPORT_PC()                            #  export the PC
-    FETCH(a1, 3)                           # a1<- BBBB
-    JAL(dvmThrowVerificationError)         #  always throws
-    b         common_exceptionThrown       #  handle exception
 
 
     .balign 128
@@ -14711,1231 +10999,6 @@
 1:
     GOTO_OPCODE(t0)                        #  jump to next instruction
 
-/* continuation for OP_CHECK_CAST_JUMBO */
-
-
-.LOP_CHECK_CAST_JUMBO_castfailure:
-    # A cast has failed.  We need to throw a ClassCastException with the
-    # class of the object that failed to be cast.
-    EXPORT_PC()                                 # about to throw
-    LOAD_base_offObject_clazz(a0, rOBJ)         # a0<- obj->clazz
-    move      a1,rBIX                      #  r1<- desired class
-    JAL(dvmThrowClassCastException)
-    b       common_exceptionThrown
-
-    /*
-     * Advance PC and get next opcode
-     *
-     */
-.LOP_CHECK_CAST_JUMBO_okay:
-    FETCH_ADVANCE_INST(4)                       # advance rPC, load rINST
-    GET_INST_OPCODE(t0)                         # extract opcode from rINST
-    GOTO_OPCODE(t0)                             # jump to next instruction
-    /*
-     * Resolution required.  This is the least-likely path.
-     *
-     *  a2   holds AAAAAAAA
-     *  rOBJ holds object
-     */
-.LOP_CHECK_CAST_JUMBO_resolve:
-    EXPORT_PC()                                 # resolve() could throw
-    LOAD_rSELF_method(a3)           # a3<- self->method
-    move     a1, a2                             # a1<- AAAAAAAA
-    li       a2, 0                              # a2<- false
-    LOAD_base_offMethod_clazz(a0, a3)   # a0<- method->clazz
-    JAL(dvmResolveClass)    # v0<- resolved ClassObject ptr
-                                                # got null?
-    beqz     v0, common_exceptionThrown         # yes, handle exception
-    move     a1, v0                             # a1<- class resolved from AAAAAAAA
-    LOAD_base_offObject_clazz(a0, rOBJ)   # a0<- obj->clazz
-    b       .LOP_CHECK_CAST_JUMBO_resolved                # pick up where we left off
-
-
-
-/* continuation for OP_INSTANCE_OF_JUMBO */
-
-     /*
-     * Class resolved, determine type of check necessary.  This is common.
-     *  r0 holds obj->clazz
-     *  r1 holds class resolved from AAAAAAAA
-     *  r9 holds BBBB
-     */
-
-.LOP_INSTANCE_OF_JUMBO_resolved:                   #  a0=obj->clazz, a1=resolved class
-    # same class (trivial success)?
-    beq       a0, a1, .LOP_INSTANCE_OF_JUMBO_trivial  #  yes, trivial finish
-    # fall through to OP_INSTANCE_OF_JUMBO_fullcheck
-
-    /*
-     * Trivial test failed, need to perform full check.  This is common.
-     *  a0 holds obj->clazz
-     *  a1 holds class resolved from AAAAAAAA
-     *  rOBJ holds BBBB
-     */
-.LOP_INSTANCE_OF_JUMBO_fullcheck:
-    JAL(dvmInstanceofNonTrivial)           #  v0 <- boolean result
-    move      a0, v0
-    b         .LOP_INSTANCE_OF_JUMBO_store            #  go to OP_INSTANCE_OF_JUMBO_store
-
-.LOP_INSTANCE_OF_JUMBO_trivial:
-    li        a0, 1                        #  indicate success
-    # fall thru
-    /*
-     * a0   holds boolean result
-     * rOBJ holds BBBB
-     */
-.LOP_INSTANCE_OF_JUMBO_store:
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, rOBJ)                     #  vBBBB <- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-    /*
-     * Resolution required.  This is the least-likely path.
-     *
-     *  a3   holds AAAAAAAA
-     *  rOBJ holds BBBB
-     */
-.LOP_INSTANCE_OF_JUMBO_resolve:
-    EXPORT_PC()                            #  resolve() could throw
-    LOAD_rSELF_method(a0)                  #  a0 <- self->method
-    move      a1, a3                       #  a1 <- AAAAAAAA
-    li        a2, 1                        #  a2 <- true
-    LOAD_base_offMethod_clazz(a0, a0)      #  a0 <- method->clazz
-    JAL(dvmResolveClass)                   #  v0 <- resolved ClassObject ptr
-    # got null?
-    move      a1, v0                       #  a1 <- class resolved from BBB
-    beqz      v0, common_exceptionThrown   #  yes, handle exception
-    FETCH(ra, 4)                           #  a3<- vCCCC
-    move       a1, a0                       #  a1<- class resolved from AAAAAAAA
-
-    GET_VREG(a0, a3)                       #  a0 <- vCCCC (object)
-    LOAD_base_offObject_clazz(a0, a0)      #  a0 <- obj->clazz
-    b         .LOP_INSTANCE_OF_JUMBO_resolved         #  pick up where we left off
-
-
-/* continuation for OP_NEW_INSTANCE_JUMBO */
-
-.LOP_NEW_INSTANCE_JUMBO_continue:
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG(v0, a3)                       #  vBBBB <- v0
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-#if defined(WITH_JIT)
-    /*
-     * Check to see if we need to stop the trace building early.
-     * v0: new object
-     * a3: vAA
-     */
-.LOP_NEW_INSTANCE_JUMBO_jitCheck:
-    lw        a1, 0(rBIX)                  #  reload resolved class
-    # okay?
-    bnez      a1, .LOP_NEW_INSTANCE_JUMBO_continue     #  yes, finish
-    move      rOBJ, v0                     #  preserve new object
-    move      rBIX, a3                     #  preserve vAA
-    move      a0, rSELF
-    move      a1, rPC
-    JAL(dvmJitEndTraceSelect)              #  (self, pc)
-    FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG(rOBJ, rBIX)                   #  vAA <- new object
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-#endif
-
-    /*
-     * Class initialization required.
-     *
-     *  a0 holds class object
-     */
-.LOP_NEW_INSTANCE_JUMBO_needinit:
-    JAL(dvmInitClass)                      #  initialize class
-    move      a0, rOBJ                     #  restore a0
-    # check boolean result
-    bnez      v0, .LOP_NEW_INSTANCE_JUMBO_initialized  #  success, continue
-    b         common_exceptionThrown       #  failed, deal with init exception
-
-
-    /*
-     * Resolution required.  This is the least-likely path.
-     *
-     *  a1 holds AAAAAAAA
-     */
-.LOP_NEW_INSTANCE_JUMBO_resolve:
-    LOAD_rSELF_method(a3)                  #  a3 <- self->method
-    li        a2, 0                        #  a2 <- false
-    LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
-    JAL(dvmResolveClass)                   #  v0 <- resolved ClassObject ptr
-    move      a0, v0
-    # got null?
-    bnez      v0, .LOP_NEW_INSTANCE_JUMBO_resolved     #  no, continue
-    b         common_exceptionThrown       #  yes, handle exception
-
-/* continuation for OP_NEW_ARRAY_JUMBO */
-
-    /*
-     * Finish allocation.
-     *
-     *  a0 holds class
-     *  a1 holds array length
-     */
-.LOP_NEW_ARRAY_JUMBO_finish:
-    li        a2, ALLOC_DONT_TRACK         #  don't track in local refs table
-    JAL(dvmAllocArrayByClass)              #  v0 <- call(clazz, length, flags)
-    FETCH(a2, 3)                           # r2<- vBBBB
-    # failed?
-    beqz      v0, common_exceptionThrown   #  yes, handle the exception
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG(v0, a2)                       #  vBBBB <- v0
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-#%break
-
-
-
-    /*
-     * Resolve class.  (This is an uncommon case.)
-     *
-     *  a1 holds array length
-     *  a2 holds class ref AAAAAAAA
-     */
-.LOP_NEW_ARRAY_JUMBO_resolve:
-    LOAD_rSELF_method(a3)                  #  a3 <- self->method
-    move      rOBJ, a1                     #  rOBJ <- length (save)
-    move      a1, a2                       #  a1 <- AAAAAAAA
-    li        a2, 0                        #  a2 <- false
-    LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
-    JAL(dvmResolveClass)                   #  v0 <- call(clazz, ref)
-    move      a1, rOBJ                     #  a1 <- length (restore)
-    # got null?
-    beqz      v0, common_exceptionThrown   #  yes, handle exception
-    move      a0, v0
-    b         .LOP_NEW_ARRAY_JUMBO_finish           #  continue with to OP_NEW_ARRAY_JUMBO_finish
-
-
-
-/* continuation for OP_FILLED_NEW_ARRAY_JUMBO */
-
-    /*
-     * On entry:
-     *  a0 holds array class
-     *  rOBJ holds AA or BA
-     */
-.LOP_FILLED_NEW_ARRAY_JUMBO_continue:
-    LOAD_base_offClassObject_descriptor(a3, a0) #  a3 <- arrayClass->descriptor
-    li        a2, ALLOC_DONT_TRACK         #  a2 <- alloc flags
-    lbu       rINST, 1(a3)                 #  rINST <- descriptor[1]
-    FETCH(a1, 3)                           # a1<- BBBB (length)
-    seq       t0, rINST, 'I'               #  array of ints?
-    seq       t1, rINST, 'L'               #  array of objects?
-    or        t0, t1
-    seq       t1, rINST, '['               #  array of arrays?
-    or        t0, t1
-    move      rBIX, a1                     #  save length in rBIX
-    beqz      t0, .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl      #  no, not handled yet
-    JAL(dvmAllocArrayByClass)              #  v0 <- call(arClass, length, flags)
-    # null return?
-    beqz      v0, common_exceptionThrown   #  alloc failed, handle exception
-
-    FETCH(a1, 4)                           #  a1 CCCC
-    sw        v0, offThread_retval(rSELF)  #  retval.l <- new array
-    sw        rINST, (offThread_retval+4)(rSELF) #  retval.h <- type
-    addu      a0, v0, offArrayObject_contents #  a0 <- newArray->contents
-    subu      rBIX, rBIX, 1                #  length--, check for neg
-    FETCH_ADVANCE_INST(5)                  #  advance to next instr, load rINST
-    bltz      rBIX, 2f                     #  was zero, bail
-
-    # copy values from registers into the array
-    # a0=array, a1=CCCC, t0=BBBB(length)
-    move      t0, rBIX
-    EAS2(a2, rFP, a1)                      #  a2 <- &fp[CCCC]
-1:
-    lw        a3, 0(a2)                    #  a3 <- *a2++
-    addu      a2, 4
-    subu      t0, t0, 1                    #  count--
-    sw        a3, (a0)                     #  *contents++ = vX
-    addu      a0, 4
-    bgez      t0, 1b
-
-2:
-    lw        a0, offThread_retval(rSELF)  #  a0 <- object
-    lw        a1, (offThread_retval+4)(rSELF) #  a1 <- type
-    seq       t1, a1, 'I'                  #  Is int array?
-    bnez      t1, 3f
-    lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
-    srl       t3, a0, GC_CARD_SHIFT
-    addu      t2, a2, t3
-    sb        a2, (t2)
-3:
-    GET_INST_OPCODE(t0)                    #  ip <- opcode from rINST
-    GOTO_OPCODE(t0)                        #  execute it
-
-
-    /*
-     * Throw an exception indicating that we have not implemented this
-     * mode of filled-new-array.
-     */
-.LOP_FILLED_NEW_ARRAY_JUMBO_notimpl:
-    la        a0, .LstrFilledNewArrayNotImpl
-    JAL(dvmThrowInternalError)
-    b         common_exceptionThrown
-
-/* continuation for OP_IGET_JUMBO */
-
-.LOP_IGET_JUMBO_resolved:
-     # test results
-    move      a0, v0
-    beqz      a0,common_exceptionThrown
-    /*
-     * Currently:
-     *  v0 holds resolved field
-     *  rOBJ holds object (caller saved)
-     */
-.LOP_IGET_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    addu      a3, a3, rOBJ                 #  form address
-    lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
-         # noop                               #  acquiring load
-    FETCH(a2, 3)                           #  a2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IGET_WIDE_JUMBO */
-
-.LOP_IGET_WIDE_JUMBO_resolved:
-    # test return code
-    move      a0, v0
-    bnez      v0, .LOP_IGET_WIDE_JUMBO_finish
-    b         common_exceptionThrown
-
-    /*
-     * Currently:
-     *  a0   holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IGET_WIDE_JUMBO_finish:
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    beqz      rOBJ, common_errNullObject   #  object was null
-    GET_OPA4(a2)                           #  a2 <- A+
-    addu      rOBJ, rOBJ, a3               #  form address
-    .if 0
-    vLOAD64(a0, a1, rOBJ)                  #  a0/a1 <- obj.field (64-bit align ok)
-    .else
-    LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- obj.field (64-bit align ok)
-    .endif
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    EAS2(a3, rFP, a2)                      #  a3 <- &fp[BBBB]
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    STORE64(a0, a1, a3)                    #  fp[BBBB] <- a0/a1
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IGET_OBJECT_JUMBO */
-
-.LOP_IGET_OBJECT_JUMBO_resolved:
-     # test results
-    move      a0, v0
-    beqz      a0,common_exceptionThrown
-    /*
-     * Currently:
-     *  v0 holds resolved field
-     *  rOBJ holds object (caller saved)
-     */
-.LOP_IGET_OBJECT_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    addu      a3, a3, rOBJ                 #  form address
-    lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
-         # noop                               #  acquiring load
-    FETCH(a2, 3)                           #  a2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IGET_BOOLEAN_JUMBO */
-
-.LOP_IGET_BOOLEAN_JUMBO_resolved:
-     # test results
-    move      a0, v0
-    beqz      a0,common_exceptionThrown
-    /*
-     * Currently:
-     *  v0 holds resolved field
-     *  rOBJ holds object (caller saved)
-     */
-.LOP_IGET_BOOLEAN_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    addu      a3, a3, rOBJ                 #  form address
-    lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
-         # noop                               #  acquiring load
-    FETCH(a2, 3)                           #  a2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IGET_BYTE_JUMBO */
-
-.LOP_IGET_BYTE_JUMBO_resolved:
-     # test results
-    move      a0, v0
-    beqz      a0,common_exceptionThrown
-    /*
-     * Currently:
-     *  v0 holds resolved field
-     *  rOBJ holds object (caller saved)
-     */
-.LOP_IGET_BYTE_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    addu      a3, a3, rOBJ                 #  form address
-    lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
-         # noop                               #  acquiring load
-    FETCH(a2, 3)                           #  a2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IGET_CHAR_JUMBO */
-
-.LOP_IGET_CHAR_JUMBO_resolved:
-     # test results
-    move      a0, v0
-    beqz      a0,common_exceptionThrown
-    /*
-     * Currently:
-     *  v0 holds resolved field
-     *  rOBJ holds object (caller saved)
-     */
-.LOP_IGET_CHAR_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    addu      a3, a3, rOBJ                 #  form address
-    lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
-         # noop                               #  acquiring load
-    FETCH(a2, 3)                           #  a2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IGET_SHORT_JUMBO */
-
-.LOP_IGET_SHORT_JUMBO_resolved:
-     # test results
-    move      a0, v0
-    beqz      a0,common_exceptionThrown
-    /*
-     * Currently:
-     *  v0 holds resolved field
-     *  rOBJ holds object (caller saved)
-     */
-.LOP_IGET_SHORT_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    addu      a3, a3, rOBJ                 #  form address
-    lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
-         # noop                               #  acquiring load
-    FETCH(a2, 3)                           #  a2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IPUT_JUMBO */
-
-.LOP_IPUT_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_JUMBO_finish
-
-
-    /*
-     * Currently:
-     *  a0 holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    FETCH(a1, 3)                           # a1<- BBBB
-    GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    addu      rOBJ, rOBJ, a3               #  form address
-        #  noop                            #  releasing store
-    sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
-    # noop 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IPUT_WIDE_JUMBO */
-
-.LOP_IPUT_WIDE_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_WIDE_JUMBO_finish
-    /*
-     * Currently:
-     *  a0   holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_WIDE_JUMBO_finish:
-    FETCH(a2, 3)                           # a1<- BBBB
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    EAS2(a2, rFP, a2)                      #  a2 <- &fp[BBBB]
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    LOAD64(a0, a1, a2)                     #  a0/a1 <- fp[BBBB]
-    GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
-    addu      a2, rOBJ, a3                 #  form address
-    .if 0
-    JAL(dvmQuasiAtomicSwap64Sync)          # stores r0/r1 into addr r2
-#    STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
-    .else
-    STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
-    .endif
-    GOTO_OPCODE(rBIX)                      #  jump to next instruction
-
-
-
-/* continuation for OP_IPUT_OBJECT_JUMBO */
-
-    /*
-     * Currently:
-     *  a0 holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_OBJECT_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_OBJECT_JUMBO_finish
-
-.LOP_IPUT_OBJECT_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    FETCH(a1, 3)                              # a1<- BBBB
-    GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
-    lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    addu      t2, rOBJ, a3                 #  form address
-        #  noop                            #  releasing store
-    sw a0, (t2)                        #  obj.field (32 bits) <- a0
-        #  noop
-    beqz      a0, 1f                       #  stored a null reference?
-    srl       t1, rOBJ, GC_CARD_SHIFT
-    addu      t2, a2, t1
-    sb        a2, (t2)                     #  mark card if not
-1:
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IPUT_BOOLEAN_JUMBO */
-
-.LOP_IPUT_BOOLEAN_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_BOOLEAN_JUMBO_finish
-
-
-    /*
-     * Currently:
-     *  a0 holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_BOOLEAN_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    FETCH(a1, 3)                           # a1<- BBBB
-    GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    addu      rOBJ, rOBJ, a3               #  form address
-        #  noop                            #  releasing store
-    sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
-    # noop 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IPUT_BYTE_JUMBO */
-
-.LOP_IPUT_BYTE_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_BYTE_JUMBO_finish
-
-
-    /*
-     * Currently:
-     *  a0 holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_BYTE_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    FETCH(a1, 3)                           # a1<- BBBB
-    GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    addu      rOBJ, rOBJ, a3               #  form address
-        #  noop                            #  releasing store
-    sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
-    # noop 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IPUT_CHAR_JUMBO */
-
-.LOP_IPUT_CHAR_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_CHAR_JUMBO_finish
-
-
-    /*
-     * Currently:
-     *  a0 holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_CHAR_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    FETCH(a1, 3)                           # a1<- BBBB
-    GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    addu      rOBJ, rOBJ, a3               #  form address
-        #  noop                            #  releasing store
-    sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
-    # noop 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IPUT_SHORT_JUMBO */
-
-.LOP_IPUT_SHORT_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_SHORT_JUMBO_finish
-
-
-    /*
-     * Currently:
-     *  a0 holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_SHORT_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    FETCH(a1, 3)                           # a1<- BBBB
-    GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    addu      rOBJ, rOBJ, a3               #  form address
-        #  noop                            #  releasing store
-    sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
-    # noop 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_SGET_JUMBO */
-
-.LOP_SGET_JUMBO_finish:
-    LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
-                      #  no-op                                #  acquiring load
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
-
-/* continuation for OP_SGET_WIDE_JUMBO */
-
-.LOP_SGET_WIDE_JUMBO_finish:
-    FETCH(a1, 3)                           # a1<- BBBB
-    .if 0
-    vLOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
-    .else
-    LOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
-    .endif
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    EAS2(a1, rFP, a1)                      #  a1 <- &fp[BBBB]
-    STORE64(a2, a3, a1)                    #  vBBBB/vBBBB+1 <- a2/a3
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_SGET_OBJECT_JUMBO */
-
-.LOP_SGET_OBJECT_JUMBO_finish:
-    LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
-                      #  no-op                                #  acquiring load
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
-
-/* continuation for OP_SGET_BOOLEAN_JUMBO */
-
-.LOP_SGET_BOOLEAN_JUMBO_finish:
-    LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
-                      #  no-op                                #  acquiring load
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
-
-/* continuation for OP_SGET_BYTE_JUMBO */
-
-.LOP_SGET_BYTE_JUMBO_finish:
-    LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
-                      #  no-op                                #  acquiring load
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
-
-/* continuation for OP_SGET_CHAR_JUMBO */
-
-.LOP_SGET_CHAR_JUMBO_finish:
-    LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
-                      #  no-op                                #  acquiring load
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
-
-/* continuation for OP_SGET_SHORT_JUMBO */
-
-.LOP_SGET_SHORT_JUMBO_finish:
-    LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
-                      #  no-op                                #  acquiring load
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
-
-/* continuation for OP_SPUT_JUMBO */
-
-.LOP_SPUT_JUMBO_finish:
-    # field ptr in a0
-    FETCH(a2, 3)                           # a2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-          #  no-op                             #  releasing store
-    sw        a1, offStaticField_value(a0) #  field <- vBBBB
-          #  no-op 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_SPUT_WIDE_JUMBO */
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rOBJ:  &fp[BBBB]
-     *  rBIX: dvmDex->pResFields
-     *
-     * Returns StaticField pointer in a2.
-     */
-.LOP_SPUT_WIDE_JUMBO_resolve:
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    # success ?
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    move      a2, v0
-    b         .LOP_SPUT_WIDE_JUMBO_finish           # resume
-
-/* continuation for OP_SPUT_OBJECT_JUMBO */
-.LOP_SPUT_OBJECT_JUMBO_finish:                     #  field ptr in a0
-    FETCH(a2, 3)                        # a2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
-    lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
-    lw        t1, offField_clazz(a0)       #  t1 <- field->clazz
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-          #  no-op                             #  releasing store
-    sw        a1, offStaticField_value(a0) #  field <- vBBBB
-          #  no-op 
-    beqz      a1, 1f
-    srl       t2, t1, GC_CARD_SHIFT
-    addu      t3, a2, t2
-    sb        a2, (t3)
-    1:
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_SPUT_BOOLEAN_JUMBO */
-
-.LOP_SPUT_BOOLEAN_JUMBO_finish:
-    # field ptr in a0
-    FETCH(a2, 3)                           # a2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-          #  no-op                             #  releasing store
-    sw        a1, offStaticField_value(a0) #  field <- vBBBB
-          #  no-op 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_SPUT_BYTE_JUMBO */
-
-.LOP_SPUT_BYTE_JUMBO_finish:
-    # field ptr in a0
-    FETCH(a2, 3)                           # a2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-          #  no-op                             #  releasing store
-    sw        a1, offStaticField_value(a0) #  field <- vBBBB
-          #  no-op 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_SPUT_CHAR_JUMBO */
-
-.LOP_SPUT_CHAR_JUMBO_finish:
-    # field ptr in a0
-    FETCH(a2, 3)                           # a2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-          #  no-op                             #  releasing store
-    sw        a1, offStaticField_value(a0) #  field <- vBBBB
-          #  no-op 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_SPUT_SHORT_JUMBO */
-
-.LOP_SPUT_SHORT_JUMBO_finish:
-    # field ptr in a0
-    FETCH(a2, 3)                           # a2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-          #  no-op                             #  releasing store
-    sw        a1, offStaticField_value(a0) #  field <- vBBBB
-          #  no-op 
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_INVOKE_VIRTUAL_JUMBO */
-
-    /*
-     * At this point:
-     *  a0 = resolved base method
-     *  rBIX= C or CCCC (index of first arg, which is the "this" ptr)
-     */
-.LOP_INVOKE_VIRTUAL_JUMBO_continue:
-    FETCH(rBIX,4)                          #  rBIX <- CCCC
-    GET_VREG(rOBJ, rBIX)                   #  rOBJ <- "this" ptr
-    LOADu2_offMethod_methodIndex(a2, a0)   #  a2 <- baseMethod->methodIndex
-    # is "this" null?
-    beqz      rOBJ, common_errNullObject   #  null "this", throw exception
-    LOAD_base_offObject_clazz(a3, rOBJ)    #  a3 <- thisPtr->clazz
-    LOAD_base_offClassObject_vtable(a3, a3) #  a3 <- thisPtr->clazz->vtable
-    LOAD_eas2(a0, a3, a2)                  #  a0 <- vtable[methodIndex]
-    b         common_invokeMethodJumbo     #  (a0=method, rOBJ="this")
-
-
-/* continuation for OP_INVOKE_SUPER_JUMBO */
-
-    /*
-     * At this point:
-     *  a0 = resolved base method
-     *  rBIX = method->clazz
-     */
-.LOP_INVOKE_SUPER_JUMBO_continue:
-    LOAD_base_offClassObject_super(a1, rBIX) #  a1 <- method->clazz->super
-    LOADu2_offMethod_methodIndex(a2, a0)   #  a2 <- baseMethod->methodIndex
-    LOAD_base_offClassObject_vtableCount(a3, a1) #  a3 <- super->vtableCount
-    EXPORT_PC()                            #  must export for invoke
-    # compare (methodIndex, vtableCount)
-    bgeu      a2, a3, .LOP_INVOKE_SUPER_JUMBO_nsm      #  method not present in superclass
-    LOAD_base_offClassObject_vtable(a1, a1) #  a1 <- ...clazz->super->vtable
-    LOAD_eas2(a0, a1, a2)                  #  a0 <- vtable[methodIndex]
-    b         common_invokeMethodJumbo     #  a0=method rOBJ="this"
-
-    /*
-     * Throw a NoSuchMethodError with the method name as the message.
-     *  a0 = resolved base method
-     */
-.LOP_INVOKE_SUPER_JUMBO_nsm:
-    LOAD_base_offMethod_name(a1, a0)       #  a1 <- method name
-    b         common_errNoSuchMethod
-
-
-/* continuation for OP_INVOKE_STATIC_JUMBO */
-
-.LOP_INVOKE_STATIC_JUMBO_resolve:
-    LOAD_rSELF_method(a3)                  #  a3 <- self->method
-    LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
-    li        a2, METHOD_STATIC            #  resolver method type
-    JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
-    move      a0, v0
-#if defined(WITH_JIT)
-    /*
-     * Check to see if we're actively building a trace.  If so,
-     * we need to keep this instruction out of it.
-     * rBIX: &resolved_methodToCall
-     */
-    lhu        a2, offThread_subMode(rSELF)
-    beqz      v0, common_exceptionThrown   #  null, handle exception
-    and       a2, kSubModeJitTraceBuild    #  trace under construction?
-    beqz      a2, common_invokeMethodJumboNoThis #  no, (a0=method, rOBJ="this")
-    lw        a1, 0(rBIX)                  #  reload resolved method
-    # finished resloving?
-    bnez      a1, common_invokeMethodJumboNoThis #  yes, (a0=method, rOBJ="this")
-    move      rBIX, a0                     #  preserve method
-    move      a0, rSELF
-    move      a1, rPC
-    JAL(dvmJitEndTraceSelect)              #  (self, pc)
-    move      a0, rBIX
-    b         common_invokeMethodJumboNoThis #  whew, finally!
-#else
-    # got null?
-    bnez      v0, common_invokeMethodJumboNoThis #  (a0=method, rOBJ="this")
-    b         common_exceptionThrown       #  yes, handle exception
-#endif
-
-/* continuation for OP_INVOKE_OBJECT_INIT_JUMBO */
-    /*
-     * A debugger is attached, so we need to go ahead and do
-     * this.  For simplicity, we'll just jump directly to the
-     * corresponding handler.  Note that we can't use
-     * rIBASE here because it may be in single-step mode.
-     * Load the primary table base directly.
-     */
-.LOP_INVOKE_OBJECT_INIT_JUMBO_debugger:
-    lw      a1, offThread_mainHandlerTable(rSELF)
-    .if 1
-    li      t0, OP_INVOKE_DIRECT_JUMBO
-    .else
-    li      t0, OP_INVOKE_DIRECT_RANGE
-    .endif
-    GOTO_OPCODE_BASE(a1, t0)            # execute it
-
-/* continuation for OP_IGET_VOLATILE_JUMBO */
-
-.LOP_IGET_VOLATILE_JUMBO_resolved:
-     # test results
-    move      a0, v0
-    beqz      a0,common_exceptionThrown
-    /*
-     * Currently:
-     *  v0 holds resolved field
-     *  rOBJ holds object (caller saved)
-     */
-.LOP_IGET_VOLATILE_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    addu      a3, a3, rOBJ                 #  form address
-    lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
-    SMP_DMB                               #  acquiring load
-    FETCH(a2, 3)                           #  a2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IGET_WIDE_VOLATILE_JUMBO */
-
-.LOP_IGET_WIDE_VOLATILE_JUMBO_resolved:
-    # test return code
-    move      a0, v0
-    bnez      v0, .LOP_IGET_WIDE_VOLATILE_JUMBO_finish
-    b         common_exceptionThrown
-
-    /*
-     * Currently:
-     *  a0   holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IGET_WIDE_VOLATILE_JUMBO_finish:
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    beqz      rOBJ, common_errNullObject   #  object was null
-    GET_OPA4(a2)                           #  a2 <- A+
-    addu      rOBJ, rOBJ, a3               #  form address
-    .if 1
-    vLOAD64(a0, a1, rOBJ)                  #  a0/a1 <- obj.field (64-bit align ok)
-    .else
-    LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- obj.field (64-bit align ok)
-    .endif
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    EAS2(a3, rFP, a2)                      #  a3 <- &fp[BBBB]
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    STORE64(a0, a1, a3)                    #  fp[BBBB] <- a0/a1
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IGET_OBJECT_VOLATILE_JUMBO */
-
-.LOP_IGET_OBJECT_VOLATILE_JUMBO_resolved:
-     # test results
-    move      a0, v0
-    beqz      a0,common_exceptionThrown
-    /*
-     * Currently:
-     *  v0 holds resolved field
-     *  rOBJ holds object (caller saved)
-     */
-.LOP_IGET_OBJECT_VOLATILE_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    addu      a3, a3, rOBJ                 #  form address
-    lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
-    SMP_DMB                               #  acquiring load
-    FETCH(a2, 3)                           #  a2<- BBBB
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IPUT_VOLATILE_JUMBO */
-
-.LOP_IPUT_VOLATILE_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_VOLATILE_JUMBO_finish
-
-
-    /*
-     * Currently:
-     *  a0 holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_VOLATILE_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    FETCH(a1, 3)                           # a1<- BBBB
-    GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    addu      rOBJ, rOBJ, a3               #  form address
-    SMP_DMB_ST                            #  releasing store
-    sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
-    SMP_DMB
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_IPUT_WIDE_VOLATILE_JUMBO */
-
-.LOP_IPUT_WIDE_VOLATILE_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_WIDE_VOLATILE_JUMBO_finish
-    /*
-     * Currently:
-     *  a0   holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_WIDE_VOLATILE_JUMBO_finish:
-    FETCH(a2, 3)                           # a1<- BBBB
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    EAS2(a2, rFP, a2)                      #  a2 <- &fp[BBBB]
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    LOAD64(a0, a1, a2)                     #  a0/a1 <- fp[BBBB]
-    GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
-    addu      a2, rOBJ, a3                 #  form address
-    .if 1
-    JAL(dvmQuasiAtomicSwap64Sync)          # stores r0/r1 into addr r2
-#    STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
-    .else
-    STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
-    .endif
-    GOTO_OPCODE(rBIX)                      #  jump to next instruction
-
-
-
-/* continuation for OP_IPUT_OBJECT_VOLATILE_JUMBO */
-
-    /*
-     * Currently:
-     *  a0 holds resolved field
-     *  rOBJ holds object
-     */
-.LOP_IPUT_OBJECT_VOLATILE_JUMBO_resolved:
-    move      a0, v0
-    beqz      a0, common_exceptionThrown
-    # fall through to OP_IPUT_OBJECT_VOLATILE_JUMBO_finish
-
-.LOP_IPUT_OBJECT_VOLATILE_JUMBO_finish:
-    #BAL(common_squeak0)
-    LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
-    FETCH(a1, 3)                              # a1<- BBBB
-    GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
-    lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
-    # check object for null
-    beqz      rOBJ, common_errNullObject   #  object was null
-    FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    addu      t2, rOBJ, a3                 #  form address
-    SMP_DMB_ST                            #  releasing store
-    sw a0, (t2)                        #  obj.field (32 bits) <- a0
-    SMP_DMB
-    beqz      a0, 1f                       #  stored a null reference?
-    srl       t1, rOBJ, GC_CARD_SHIFT
-    addu      t2, a2, t1
-    sb        a2, (t2)                     #  mark card if not
-1:
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-
-/* continuation for OP_SGET_VOLATILE_JUMBO */
-
-.LOP_SGET_VOLATILE_JUMBO_finish:
-    LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
-    SMP_DMB                               #  acquiring load
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
-
-/* continuation for OP_SGET_WIDE_VOLATILE_JUMBO */
-
-.LOP_SGET_WIDE_VOLATILE_JUMBO_finish:
-    FETCH(a1, 3)                           # a1<- BBBB
-    .if 1
-    vLOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
-    .else
-    LOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
-    .endif
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    EAS2(a1, rFP, a1)                      #  a1 <- &fp[BBBB]
-    STORE64(a2, a3, a1)                    #  vBBBB/vBBBB+1 <- a2/a3
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_SGET_OBJECT_VOLATILE_JUMBO */
-
-.LOP_SGET_OBJECT_VOLATILE_JUMBO_finish:
-    LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
-    SMP_DMB                               #  acquiring load
-    FETCH(a2, 3)                           # r2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
-
-/* continuation for OP_SPUT_VOLATILE_JUMBO */
-
-.LOP_SPUT_VOLATILE_JUMBO_finish:
-    # field ptr in a0
-    FETCH(a2, 3)                           # a2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SMP_DMB_ST                            #  releasing store
-    sw        a1, offStaticField_value(a0) #  field <- vBBBB
-    SMP_DMB
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
-/* continuation for OP_SPUT_WIDE_VOLATILE_JUMBO */
-
-    /*
-     * Continuation if the field has not yet been resolved.
-     *  a1:  AAAAAAAA field ref
-     *  rOBJ:  &fp[BBBB]
-     *  rBIX: dvmDex->pResFields
-     *
-     * Returns StaticField pointer in a2.
-     */
-.LOP_SPUT_WIDE_VOLATILE_JUMBO_resolve:
-    LOAD_rSELF_method(a2)                  #  a2 <- current method
-#if defined(WITH_JIT)
-    EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
-#endif
-    EXPORT_PC()                            #  resolve() could throw, so export now
-    LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
-    JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
-    # success ?
-    move      a0, v0
-    beqz      v0, common_exceptionThrown   #  no, handle exception
-#if defined(WITH_JIT)
-    /*
-     * If the JIT is actively building a trace we need to make sure
-     * that the field is fully resolved before including this instruction.
-     */
-    JAL(common_verifyField)
-#endif
-    move      a2, v0
-    b         .LOP_SPUT_WIDE_VOLATILE_JUMBO_finish           # resume
-
-/* continuation for OP_SPUT_OBJECT_VOLATILE_JUMBO */
-.LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish:                     #  field ptr in a0
-    FETCH(a2, 3)                        # a2<- BBBB
-    FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
-    GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
-    lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
-    lw        t1, offField_clazz(a0)       #  t1 <- field->clazz
-    GET_INST_OPCODE(t0)                    #  extract opcode from rINST
-    SMP_DMB_ST                            #  releasing store
-    sw        a1, offStaticField_value(a0) #  field <- vBBBB
-    SMP_DMB
-    beqz      a1, 1f
-    srl       t2, t1, GC_CARD_SHIFT
-    addu      t3, a2, t2
-    sb        a2, (t3)
-    1:
-    GOTO_OPCODE(t0)                        #  jump to next instruction
-
     .size   dvmAsmSisterStart, .-dvmAsmSisterStart
     .global dvmAsmSisterEnd
 dvmAsmSisterEnd:
@@ -23530,7 +18593,7 @@
 
 /* ------------------------------ */
     .balign 128
-.L_ALT_OP_DISPATCH_FF: /* 0xff */
+.L_ALT_OP_UNUSED_FF: /* 0xff */
 /* File: mips/alt_stub.S */
 /*
  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
@@ -23553,6406 +18616,6 @@
     JAL(dvmCheckBefore)
     jr     rBIX
 
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_CONST_CLASS_JUMBO: /* 0x100 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (256 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_CHECK_CAST_JUMBO: /* 0x101 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (257 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_INSTANCE_OF_JUMBO: /* 0x102 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (258 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_NEW_INSTANCE_JUMBO: /* 0x103 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (259 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_NEW_ARRAY_JUMBO: /* 0x104 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (260 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (261 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_JUMBO: /* 0x106 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (262 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_WIDE_JUMBO: /* 0x107 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (263 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_OBJECT_JUMBO: /* 0x108 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (264 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (265 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_BYTE_JUMBO: /* 0x10a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (266 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_CHAR_JUMBO: /* 0x10b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (267 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_SHORT_JUMBO: /* 0x10c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (268 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_JUMBO: /* 0x10d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (269 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_WIDE_JUMBO: /* 0x10e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (270 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_OBJECT_JUMBO: /* 0x10f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (271 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (272 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_BYTE_JUMBO: /* 0x111 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (273 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_CHAR_JUMBO: /* 0x112 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (274 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_SHORT_JUMBO: /* 0x113 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (275 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_JUMBO: /* 0x114 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (276 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_WIDE_JUMBO: /* 0x115 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (277 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_OBJECT_JUMBO: /* 0x116 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (278 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (279 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_BYTE_JUMBO: /* 0x118 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (280 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_CHAR_JUMBO: /* 0x119 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (281 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_SHORT_JUMBO: /* 0x11a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (282 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_JUMBO: /* 0x11b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (283 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_WIDE_JUMBO: /* 0x11c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (284 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_OBJECT_JUMBO: /* 0x11d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (285 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (286 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_BYTE_JUMBO: /* 0x11f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (287 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_CHAR_JUMBO: /* 0x120 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (288 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_SHORT_JUMBO: /* 0x121 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (289 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (290 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_INVOKE_SUPER_JUMBO: /* 0x123 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (291 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (292 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_INVOKE_STATIC_JUMBO: /* 0x125 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (293 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (294 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_27FF: /* 0x127 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (295 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_28FF: /* 0x128 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (296 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_29FF: /* 0x129 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (297 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_2AFF: /* 0x12a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (298 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_2BFF: /* 0x12b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (299 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_2CFF: /* 0x12c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (300 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_2DFF: /* 0x12d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (301 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_2EFF: /* 0x12e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (302 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_2FFF: /* 0x12f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (303 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_30FF: /* 0x130 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (304 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_31FF: /* 0x131 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (305 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_32FF: /* 0x132 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (306 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_33FF: /* 0x133 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (307 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_34FF: /* 0x134 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (308 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_35FF: /* 0x135 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (309 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_36FF: /* 0x136 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (310 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_37FF: /* 0x137 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (311 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_38FF: /* 0x138 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (312 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_39FF: /* 0x139 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (313 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_3AFF: /* 0x13a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (314 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_3BFF: /* 0x13b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (315 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_3CFF: /* 0x13c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (316 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_3DFF: /* 0x13d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (317 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_3EFF: /* 0x13e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (318 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_3FFF: /* 0x13f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (319 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_40FF: /* 0x140 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (320 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_41FF: /* 0x141 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (321 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_42FF: /* 0x142 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (322 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_43FF: /* 0x143 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (323 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_44FF: /* 0x144 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (324 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_45FF: /* 0x145 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (325 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_46FF: /* 0x146 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (326 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_47FF: /* 0x147 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (327 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_48FF: /* 0x148 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (328 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_49FF: /* 0x149 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (329 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_4AFF: /* 0x14a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (330 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_4BFF: /* 0x14b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (331 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_4CFF: /* 0x14c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (332 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_4DFF: /* 0x14d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (333 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_4EFF: /* 0x14e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (334 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_4FFF: /* 0x14f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (335 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_50FF: /* 0x150 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (336 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_51FF: /* 0x151 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (337 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_52FF: /* 0x152 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (338 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_53FF: /* 0x153 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (339 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_54FF: /* 0x154 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (340 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_55FF: /* 0x155 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (341 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_56FF: /* 0x156 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (342 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_57FF: /* 0x157 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (343 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_58FF: /* 0x158 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (344 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_59FF: /* 0x159 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (345 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_5AFF: /* 0x15a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (346 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_5BFF: /* 0x15b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (347 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_5CFF: /* 0x15c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (348 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_5DFF: /* 0x15d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (349 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_5EFF: /* 0x15e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (350 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_5FFF: /* 0x15f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (351 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_60FF: /* 0x160 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (352 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_61FF: /* 0x161 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (353 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_62FF: /* 0x162 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (354 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_63FF: /* 0x163 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (355 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_64FF: /* 0x164 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (356 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_65FF: /* 0x165 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (357 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_66FF: /* 0x166 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (358 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_67FF: /* 0x167 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (359 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_68FF: /* 0x168 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (360 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_69FF: /* 0x169 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (361 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_6AFF: /* 0x16a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (362 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_6BFF: /* 0x16b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (363 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_6CFF: /* 0x16c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (364 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_6DFF: /* 0x16d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (365 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_6EFF: /* 0x16e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (366 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_6FFF: /* 0x16f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (367 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_70FF: /* 0x170 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (368 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_71FF: /* 0x171 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (369 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_72FF: /* 0x172 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (370 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_73FF: /* 0x173 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (371 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_74FF: /* 0x174 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (372 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_75FF: /* 0x175 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (373 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_76FF: /* 0x176 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (374 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_77FF: /* 0x177 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (375 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_78FF: /* 0x178 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (376 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_79FF: /* 0x179 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (377 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_7AFF: /* 0x17a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (378 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_7BFF: /* 0x17b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (379 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_7CFF: /* 0x17c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (380 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_7DFF: /* 0x17d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (381 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_7EFF: /* 0x17e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (382 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_7FFF: /* 0x17f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (383 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_80FF: /* 0x180 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (384 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_81FF: /* 0x181 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (385 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_82FF: /* 0x182 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (386 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_83FF: /* 0x183 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (387 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_84FF: /* 0x184 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (388 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_85FF: /* 0x185 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (389 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_86FF: /* 0x186 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (390 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_87FF: /* 0x187 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (391 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_88FF: /* 0x188 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (392 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_89FF: /* 0x189 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (393 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_8AFF: /* 0x18a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (394 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_8BFF: /* 0x18b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (395 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_8CFF: /* 0x18c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (396 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_8DFF: /* 0x18d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (397 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_8EFF: /* 0x18e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (398 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_8FFF: /* 0x18f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (399 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_90FF: /* 0x190 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (400 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_91FF: /* 0x191 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (401 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_92FF: /* 0x192 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (402 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_93FF: /* 0x193 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (403 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_94FF: /* 0x194 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (404 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_95FF: /* 0x195 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (405 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_96FF: /* 0x196 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (406 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_97FF: /* 0x197 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (407 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_98FF: /* 0x198 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (408 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_99FF: /* 0x199 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (409 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_9AFF: /* 0x19a */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (410 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_9BFF: /* 0x19b */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (411 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_9CFF: /* 0x19c */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (412 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_9DFF: /* 0x19d */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (413 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_9EFF: /* 0x19e */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (414 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_9FFF: /* 0x19f */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (415 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A0FF: /* 0x1a0 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (416 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A1FF: /* 0x1a1 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (417 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A2FF: /* 0x1a2 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (418 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A3FF: /* 0x1a3 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (419 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A4FF: /* 0x1a4 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (420 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A5FF: /* 0x1a5 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (421 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A6FF: /* 0x1a6 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (422 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A7FF: /* 0x1a7 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (423 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A8FF: /* 0x1a8 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (424 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_A9FF: /* 0x1a9 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (425 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_AAFF: /* 0x1aa */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (426 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_ABFF: /* 0x1ab */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (427 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_ACFF: /* 0x1ac */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (428 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_ADFF: /* 0x1ad */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (429 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_AEFF: /* 0x1ae */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (430 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_AFFF: /* 0x1af */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (431 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B0FF: /* 0x1b0 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (432 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B1FF: /* 0x1b1 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (433 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B2FF: /* 0x1b2 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (434 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B3FF: /* 0x1b3 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (435 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B4FF: /* 0x1b4 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (436 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B5FF: /* 0x1b5 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (437 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B6FF: /* 0x1b6 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (438 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B7FF: /* 0x1b7 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (439 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B8FF: /* 0x1b8 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (440 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_B9FF: /* 0x1b9 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (441 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_BAFF: /* 0x1ba */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (442 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_BBFF: /* 0x1bb */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (443 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_BCFF: /* 0x1bc */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (444 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_BDFF: /* 0x1bd */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (445 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_BEFF: /* 0x1be */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (446 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_BFFF: /* 0x1bf */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (447 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C0FF: /* 0x1c0 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (448 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C1FF: /* 0x1c1 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (449 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C2FF: /* 0x1c2 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (450 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C3FF: /* 0x1c3 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (451 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C4FF: /* 0x1c4 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (452 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C5FF: /* 0x1c5 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (453 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C6FF: /* 0x1c6 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (454 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C7FF: /* 0x1c7 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (455 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C8FF: /* 0x1c8 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (456 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_C9FF: /* 0x1c9 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (457 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_CAFF: /* 0x1ca */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (458 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_CBFF: /* 0x1cb */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (459 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_CCFF: /* 0x1cc */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (460 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_CDFF: /* 0x1cd */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (461 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_CEFF: /* 0x1ce */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (462 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_CFFF: /* 0x1cf */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (463 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D0FF: /* 0x1d0 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (464 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D1FF: /* 0x1d1 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (465 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D2FF: /* 0x1d2 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (466 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D3FF: /* 0x1d3 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (467 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D4FF: /* 0x1d4 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (468 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D5FF: /* 0x1d5 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (469 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D6FF: /* 0x1d6 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (470 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D7FF: /* 0x1d7 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (471 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D8FF: /* 0x1d8 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (472 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_D9FF: /* 0x1d9 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (473 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_DAFF: /* 0x1da */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (474 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_DBFF: /* 0x1db */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (475 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_DCFF: /* 0x1dc */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (476 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_DDFF: /* 0x1dd */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (477 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_DEFF: /* 0x1de */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (478 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_DFFF: /* 0x1df */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (479 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E0FF: /* 0x1e0 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (480 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E1FF: /* 0x1e1 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (481 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E2FF: /* 0x1e2 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (482 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E3FF: /* 0x1e3 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (483 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E4FF: /* 0x1e4 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (484 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E5FF: /* 0x1e5 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (485 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E6FF: /* 0x1e6 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (486 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E7FF: /* 0x1e7 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (487 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E8FF: /* 0x1e8 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (488 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_E9FF: /* 0x1e9 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (489 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_EAFF: /* 0x1ea */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (490 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_EBFF: /* 0x1eb */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (491 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_ECFF: /* 0x1ec */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (492 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_EDFF: /* 0x1ed */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (493 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_EEFF: /* 0x1ee */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (494 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_EFFF: /* 0x1ef */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (495 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_F0FF: /* 0x1f0 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (496 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_UNUSED_F1FF: /* 0x1f1 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (497 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (498 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (499 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (500 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (501 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (502 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (503 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (504 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (505 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (506 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (507 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (508 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (509 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (510 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
-/* ------------------------------ */
-    .balign 128
-.L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */
-/* File: mips/alt_stub.S */
-/*
- * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
- * any interesting requests and then jump to the real instruction
- * handler.    Note that the call to dvmCheckBefore is done as a tail call.
- * rIBASE updates won't be seen until a refresh, and we can tell we have a
- * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
- * bail to the real handler if breakFlags==0.
- */
-    lbu    a3, offThread_breakFlags(rSELF)
-    la     rBIX, dvmAsmInstructionStart + (511 * 128)
-    lw     rIBASE, offThread_curHandlerTable(rSELF)
-    bnez   a3, 1f
-    jr     rBIX            # nothing to do - jump to real handler
-1:
-    EXPORT_PC()
-    move   a0, rPC         # arg0
-    move   a1, rFP         # arg1
-    move   a2, rSELF       # arg2
-    JAL(dvmCheckBefore)
-    jr     rBIX
-
     .balign 128
     .size   dvmAsmAltInstructionStart, .-dvmAsmAltInstructionStart
     .global dvmAsmAltInstructionEnd
diff --git a/vm/mterp/out/InterpC-mips.cpp b/vm/mterp/out/InterpC-mips.cpp
index 02f8856..69260da 100644
--- a/vm/mterp/out/InterpC-mips.cpp
+++ b/vm/mterp/out/InterpC-mips.cpp
@@ -110,7 +110,7 @@
         {                                                                   \
             char* desc;                                                     \
             desc = dexProtoCopyMethodDescriptor(&curMethod->prototype);     \
-            LOGE("Invalid branch %d at 0x%04x in %s.%s %s",                 \
+            ALOGE("Invalid branch %d at 0x%04x in %s.%s %s",                 \
                 myoff, (int) (pc - curMethod->insns),                       \
                 curMethod->clazz->descriptor, curMethod->name, desc);       \
             free(desc);                                                     \
@@ -136,10 +136,10 @@
         char debugStrBuf[128];                                              \
         snprintf(debugStrBuf, sizeof(debugStrBuf), __VA_ARGS__);            \
         if (curMethod != NULL)                                              \
-            LOG(_level, LOG_TAG"i", "%-2d|%04x%s",                          \
+            ALOG(_level, LOG_TAG"i", "%-2d|%04x%s",                          \
                 self->threadId, (int)(pc - curMethod->insns), debugStrBuf); \
         else                                                                \
-            LOG(_level, LOG_TAG"i", "%-2d|####%s",                          \
+            ALOG(_level, LOG_TAG"i", "%-2d|####%s",                          \
                 self->threadId, debugStrBuf);                               \
     } while(false)
 void dvmDumpRegs(const Method* method, const u4* framePtr, bool inOnly);
@@ -328,15 +328,15 @@
         return false;
     }
 #ifdef WITH_EXTRA_OBJECT_VALIDATION
-    if (!dvmIsHeapAddressObject(obj)) {
-        LOGE("Invalid object %p", obj);
+    if (!dvmIsHeapAddress(obj)) {
+        ALOGE("Invalid object %p", obj);
         dvmAbort();
     }
 #endif
 #ifndef NDEBUG
     if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) {
         /* probable heap corruption */
-        LOGE("Invalid object class %p (in %p)", obj->clazz, obj);
+        ALOGE("Invalid object class %p (in %p)", obj->clazz, obj);
         dvmAbort();
     }
 #endif
@@ -361,14 +361,14 @@
     }
 #ifdef WITH_EXTRA_OBJECT_VALIDATION
     if (!dvmIsHeapAddress(obj)) {
-        LOGE("Invalid object %p", obj);
+        ALOGE("Invalid object %p", obj);
         dvmAbort();
     }
 #endif
 #ifndef NDEBUG
     if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) {
         /* probable heap corruption */
-        LOGE("Invalid object class %p (in %p)", obj->clazz, obj);
+        ALOGE("Invalid object class %p (in %p)", obj->clazz, obj);
         dvmAbort();
     }
 #endif
@@ -481,9 +481,9 @@
         return;                                                             \
     } while(false)
 
-#define GOTO_invoke(_target, _methodCallRange, _jumboFormat)                \
+#define GOTO_invoke(_target, _methodCallRange)                              \
     do {                                                                    \
-        dvmMterp_##_target(self, _methodCallRange, _jumboFormat);           \
+        dvmMterp_##_target(self, _methodCallRange);                         \
         return;                                                             \
     } while(false)
 
@@ -515,14 +515,14 @@
 
 /* File: c/opcommon.cpp */
 /* forward declarations of goto targets */
-GOTO_TARGET_DECL(filledNewArray, bool methodCallRange, bool jumboFormat);
-GOTO_TARGET_DECL(invokeVirtual, bool methodCallRange, bool jumboFormat);
-GOTO_TARGET_DECL(invokeSuper, bool methodCallRange, bool jumboFormat);
-GOTO_TARGET_DECL(invokeInterface, bool methodCallRange, bool jumboFormat);
-GOTO_TARGET_DECL(invokeDirect, bool methodCallRange, bool jumboFormat);
-GOTO_TARGET_DECL(invokeStatic, bool methodCallRange, bool jumboFormat);
-GOTO_TARGET_DECL(invokeVirtualQuick, bool methodCallRange, bool jumboFormat);
-GOTO_TARGET_DECL(invokeSuperQuick, bool methodCallRange, bool jumboFormat);
+GOTO_TARGET_DECL(filledNewArray, bool methodCallRange);
+GOTO_TARGET_DECL(invokeVirtual, bool methodCallRange);
+GOTO_TARGET_DECL(invokeSuper, bool methodCallRange);
+GOTO_TARGET_DECL(invokeInterface, bool methodCallRange);
+GOTO_TARGET_DECL(invokeDirect, bool methodCallRange);
+GOTO_TARGET_DECL(invokeStatic, bool methodCallRange);
+GOTO_TARGET_DECL(invokeVirtualQuick, bool methodCallRange);
+GOTO_TARGET_DECL(invokeSuperQuick, bool methodCallRange);
 GOTO_TARGET_DECL(invokeMethod, bool methodCallRange, const Method* methodToCall,
     u2 count, u2 regs);
 GOTO_TARGET_DECL(returnFromMethod);
@@ -1046,33 +1046,6 @@
     }                                                                       \
     FINISH(2);
 
-#define HANDLE_IGET_X_JUMBO(_opcode, _opname, _ftype, _regsize)             \
-    HANDLE_OPCODE(_opcode /*vBBBB, vCCCC, class@AAAAAAAA*/)                 \
-    {                                                                       \
-        InstField* ifield;                                                  \
-        Object* obj;                                                        \
-        EXPORT_PC();                                                        \
-        ref = FETCH(1) | (u4)FETCH(2) << 16;   /* field ref */              \
-        vdst = FETCH(3);                                                    \
-        vsrc1 = FETCH(4);                      /* object ptr */             \
-        ILOGV("|iget%s/jumbo v%d,v%d,field@0x%08x",                         \
-            (_opname), vdst, vsrc1, ref);                                   \
-        obj = (Object*) GET_REGISTER(vsrc1);                                \
-        if (!checkForNull(obj))                                             \
-            GOTO_exceptionThrown();                                         \
-        ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref);  \
-        if (ifield == NULL) {                                               \
-            ifield = dvmResolveInstField(curMethod->clazz, ref);            \
-            if (ifield == NULL)                                             \
-                GOTO_exceptionThrown();                                     \
-        }                                                                   \
-        SET_REGISTER##_regsize(vdst,                                        \
-            dvmGetField##_ftype(obj, ifield->byteOffset));                  \
-        ILOGV("+ IGET '%s'=0x%08llx", ifield->name,                         \
-            (u8) GET_REGISTER##_regsize(vdst));                             \
-    }                                                                       \
-    FINISH(5);
-
 #define HANDLE_IGET_X_QUICK(_opcode, _opname, _ftype, _regsize)             \
     HANDLE_OPCODE(_opcode /*vA, vB, field@CCCC*/)                           \
     {                                                                       \
@@ -1117,33 +1090,6 @@
     }                                                                       \
     FINISH(2);
 
-#define HANDLE_IPUT_X_JUMBO(_opcode, _opname, _ftype, _regsize)             \
-    HANDLE_OPCODE(_opcode /*vBBBB, vCCCC, class@AAAAAAAA*/)                 \
-    {                                                                       \
-        InstField* ifield;                                                  \
-        Object* obj;                                                        \
-        EXPORT_PC();                                                        \
-        ref = FETCH(1) | (u4)FETCH(2) << 16;   /* field ref */              \
-        vdst = FETCH(3);                                                    \
-        vsrc1 = FETCH(4);                      /* object ptr */             \
-        ILOGV("|iput%s/jumbo v%d,v%d,field@0x%08x",                         \
-            (_opname), vdst, vsrc1, ref);                                   \
-        obj = (Object*) GET_REGISTER(vsrc1);                                \
-        if (!checkForNull(obj))                                             \
-            GOTO_exceptionThrown();                                         \
-        ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref);  \
-        if (ifield == NULL) {                                               \
-            ifield = dvmResolveInstField(curMethod->clazz, ref);            \
-            if (ifield == NULL)                                             \
-                GOTO_exceptionThrown();                                     \
-        }                                                                   \
-        dvmSetField##_ftype(obj, ifield->byteOffset,                        \
-            GET_REGISTER##_regsize(vdst));                                  \
-        ILOGV("+ IPUT '%s'=0x%08llx", ifield->name,                         \
-            (u8) GET_REGISTER##_regsize(vdst));                             \
-    }                                                                       \
-    FINISH(5);
-
 #define HANDLE_IPUT_X_QUICK(_opcode, _opname, _ftype, _regsize)             \
     HANDLE_OPCODE(_opcode /*vA, vB, field@CCCC*/)                           \
     {                                                                       \
@@ -1193,29 +1139,6 @@
     }                                                                       \
     FINISH(2);
 
-#define HANDLE_SGET_X_JUMBO(_opcode, _opname, _ftype, _regsize)             \
-    HANDLE_OPCODE(_opcode /*vBBBB, class@AAAAAAAA*/)                        \
-    {                                                                       \
-        StaticField* sfield;                                                \
-        ref = FETCH(1) | (u4)FETCH(2) << 16;   /* field ref */              \
-        vdst = FETCH(3);                                                    \
-        ILOGV("|sget%s/jumbo v%d,sfield@0x%08x", (_opname), vdst, ref);     \
-        sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \
-        if (sfield == NULL) {                                               \
-            EXPORT_PC();                                                    \
-            sfield = dvmResolveStaticField(curMethod->clazz, ref);          \
-            if (sfield == NULL)                                             \
-                GOTO_exceptionThrown();                                     \
-            if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) {      \
-                JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc));               \
-            }                                                               \
-        }                                                                   \
-        SET_REGISTER##_regsize(vdst, dvmGetStaticField##_ftype(sfield));    \
-        ILOGV("+ SGET '%s'=0x%08llx",                                       \
-            sfield->name, (u8)GET_REGISTER##_regsize(vdst));                \
-    }                                                                       \
-    FINISH(4);
-
 #define HANDLE_SPUT_X(_opcode, _opname, _ftype, _regsize)                   \
     HANDLE_OPCODE(_opcode /*vAA, field@BBBB*/)                              \
     {                                                                       \
@@ -1239,29 +1162,6 @@
     }                                                                       \
     FINISH(2);
 
-#define HANDLE_SPUT_X_JUMBO(_opcode, _opname, _ftype, _regsize)             \
-    HANDLE_OPCODE(_opcode /*vBBBB, class@AAAAAAAA*/)                        \
-    {                                                                       \
-        StaticField* sfield;                                                \
-        ref = FETCH(1) | (u4)FETCH(2) << 16;   /* field ref */              \
-        vdst = FETCH(3);                                                    \
-        ILOGV("|sput%s/jumbo v%d,sfield@0x%08x", (_opname), vdst, ref);     \
-        sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \
-        if (sfield == NULL) {                                               \
-            EXPORT_PC();                                                    \
-            sfield = dvmResolveStaticField(curMethod->clazz, ref);          \
-            if (sfield == NULL)                                             \
-                GOTO_exceptionThrown();                                     \
-            if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) {      \
-                JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc));               \
-            }                                                               \
-        }                                                                   \
-        dvmSetStaticField##_ftype(sfield, GET_REGISTER##_regsize(vdst));    \
-        ILOGV("+ SPUT '%s'=0x%08llx",                                       \
-            sfield->name, (u8)GET_REGISTER##_regsize(vdst));                \
-    }                                                                       \
-    FINISH(4);
-
 /* File: c/OP_BREAKPOINT.cpp */
 HANDLE_OPCODE(OP_BREAKPOINT)
     {
@@ -1281,21 +1181,13 @@
          * the thread resumed.
          */
         u1 originalOpcode = dvmGetOriginalOpcode(pc);
-        LOGV("+++ break 0x%02x (0x%04x -> 0x%04x)", originalOpcode, inst,
+        ALOGV("+++ break 0x%02x (0x%04x -> 0x%04x)", originalOpcode, inst,
             INST_REPLACE_OP(inst, originalOpcode));
         inst = INST_REPLACE_OP(inst, originalOpcode);
         FINISH_BKPT(originalOpcode);
     }
 OP_END
 
-/* File: c/OP_DISPATCH_FF.cpp */
-HANDLE_OPCODE(OP_DISPATCH_FF)
-    /*
-     * Indicates extended opcode.  Use next 8 bits to choose where to branch.
-     */
-    DISPATCH_EXTENDED(INST_AA(inst));
-OP_END
-
 /* File: c/gotoTargets.cpp */
 /*
  * C footer.  This has some common code shared by the various targets.
@@ -1307,7 +1199,7 @@
  * next instruction.  Here, these are subroutines that return to the caller.
  */
 
-GOTO_TARGET(filledNewArray, bool methodCallRange, bool jumboFormat)
+GOTO_TARGET(filledNewArray, bool methodCallRange, bool)
     {
         ClassObject* arrayClass;
         ArrayObject* newArray;
@@ -1318,28 +1210,19 @@
 
         EXPORT_PC();
 
-        if (jumboFormat) {
-            ref = FETCH(1) | (u4)FETCH(2) << 16;  /* class ref */
-            vsrc1 = FETCH(3);                     /* #of elements */
-            vdst = FETCH(4);                      /* range base */
-            arg5 = -1;                            /* silence compiler warning */
-            ILOGV("|filled-new-array/jumbo args=%d @0x%08x {regs=v%d-v%d}",
+        ref = FETCH(1);             /* class ref */
+        vdst = FETCH(2);            /* first 4 regs -or- range base */
+
+        if (methodCallRange) {
+            vsrc1 = INST_AA(inst);  /* #of elements */
+            arg5 = -1;              /* silence compiler warning */
+            ILOGV("|filled-new-array-range args=%d @0x%04x {regs=v%d-v%d}",
                 vsrc1, ref, vdst, vdst+vsrc1-1);
         } else {
-            ref = FETCH(1);             /* class ref */
-            vdst = FETCH(2);            /* first 4 regs -or- range base */
-
-            if (methodCallRange) {
-                vsrc1 = INST_AA(inst);  /* #of elements */
-                arg5 = -1;              /* silence compiler warning */
-                ILOGV("|filled-new-array-range args=%d @0x%04x {regs=v%d-v%d}",
-                    vsrc1, ref, vdst, vdst+vsrc1-1);
-            } else {
-                arg5 = INST_A(inst);
-                vsrc1 = INST_B(inst);   /* #of elements */
-                ILOGV("|filled-new-array args=%d @0x%04x {regs=0x%04x %x}",
-                   vsrc1, ref, vdst, arg5);
-            }
+            arg5 = INST_A(inst);
+            vsrc1 = INST_B(inst);   /* #of elements */
+            ILOGV("|filled-new-array args=%d @0x%04x {regs=0x%04x %x}",
+               vsrc1, ref, vdst, arg5);
         }
 
         /*
@@ -1373,7 +1256,7 @@
             GOTO_exceptionThrown();
         } else if (typeCh != 'L' && typeCh != '[' && typeCh != 'I') {
             /* TODO: requires multiple "fill in" loops with different widths */
-            LOGE("non-int primitives not implemented");
+            ALOGE("non-int primitives not implemented");
             dvmThrowInternalError(
                 "filled-new-array not implemented for anything but 'int'");
             GOTO_exceptionThrown();
@@ -1407,49 +1290,35 @@
 
         retval.l = (Object*)newArray;
     }
-    if (jumboFormat) {
-        FINISH(5);
-    } else {
-        FINISH(3);
-    }
+    FINISH(3);
 GOTO_TARGET_END
 
 
-GOTO_TARGET(invokeVirtual, bool methodCallRange, bool jumboFormat)
+GOTO_TARGET(invokeVirtual, bool methodCallRange, bool)
     {
         Method* baseMethod;
         Object* thisPtr;
 
         EXPORT_PC();
 
-        if (jumboFormat) {
-            ref = FETCH(1) | (u4)FETCH(2) << 16;  /* method ref */
-            vsrc1 = FETCH(3);                     /* count */
-            vdst = FETCH(4);                      /* first reg */
-            ADJUST_PC(2);     /* advance pc partially to make returns easier */
-            ILOGV("|invoke-virtual/jumbo args=%d @0x%08x {regs=v%d-v%d}",
+        vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
+        ref = FETCH(1);             /* method ref */
+        vdst = FETCH(2);            /* 4 regs -or- first reg */
+
+        /*
+         * The object against which we are executing a method is always
+         * in the first argument.
+         */
+        if (methodCallRange) {
+            assert(vsrc1 > 0);
+            ILOGV("|invoke-virtual-range args=%d @0x%04x {regs=v%d-v%d}",
                 vsrc1, ref, vdst, vdst+vsrc1-1);
             thisPtr = (Object*) GET_REGISTER(vdst);
         } else {
-            vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
-            ref = FETCH(1);             /* method ref */
-            vdst = FETCH(2);            /* 4 regs -or- first reg */
-
-            /*
-             * The object against which we are executing a method is always
-             * in the first argument.
-             */
-            if (methodCallRange) {
-                assert(vsrc1 > 0);
-                ILOGV("|invoke-virtual-range args=%d @0x%04x {regs=v%d-v%d}",
-                    vsrc1, ref, vdst, vdst+vsrc1-1);
-                thisPtr = (Object*) GET_REGISTER(vdst);
-            } else {
-                assert((vsrc1>>4) > 0);
-                ILOGV("|invoke-virtual args=%d @0x%04x {regs=0x%04x %x}",
-                    vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
-                thisPtr = (Object*) GET_REGISTER(vdst & 0x0f);
-            }
+            assert((vsrc1>>4) > 0);
+            ILOGV("|invoke-virtual args=%d @0x%04x {regs=0x%04x %x}",
+                vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
+            thisPtr = (Object*) GET_REGISTER(vdst & 0x0f);
         }
 
         if (!checkForNull(thisPtr))
@@ -1507,7 +1376,7 @@
 
 #if 0
         if (vsrc1 != methodToCall->insSize) {
-            LOGW("WRONG METHOD: base=%s.%s virtual[%d]=%s.%s",
+            ALOGW("WRONG METHOD: base=%s.%s virtual[%d]=%s.%s",
                 baseMethod->clazz->descriptor, baseMethod->name,
                 (u4) baseMethod->methodIndex,
                 methodToCall->clazz->descriptor, methodToCall->name);
@@ -1521,35 +1390,25 @@
     }
 GOTO_TARGET_END
 
-GOTO_TARGET(invokeSuper, bool methodCallRange, bool jumboFormat)
+GOTO_TARGET(invokeSuper, bool methodCallRange)
     {
         Method* baseMethod;
         u2 thisReg;
 
         EXPORT_PC();
 
-        if (jumboFormat) {
-            ref = FETCH(1) | (u4)FETCH(2) << 16;  /* method ref */
-            vsrc1 = FETCH(3);                     /* count */
-            vdst = FETCH(4);                      /* first reg */
-            ADJUST_PC(2);     /* advance pc partially to make returns easier */
-            ILOGV("|invoke-super/jumbo args=%d @0x%08x {regs=v%d-v%d}",
+        vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
+        ref = FETCH(1);             /* method ref */
+        vdst = FETCH(2);            /* 4 regs -or- first reg */
+
+        if (methodCallRange) {
+            ILOGV("|invoke-super-range args=%d @0x%04x {regs=v%d-v%d}",
                 vsrc1, ref, vdst, vdst+vsrc1-1);
             thisReg = vdst;
         } else {
-            vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
-            ref = FETCH(1);             /* method ref */
-            vdst = FETCH(2);            /* 4 regs -or- first reg */
-
-            if (methodCallRange) {
-                ILOGV("|invoke-super-range args=%d @0x%04x {regs=v%d-v%d}",
-                    vsrc1, ref, vdst, vdst+vsrc1-1);
-                thisReg = vdst;
-            } else {
-                ILOGV("|invoke-super args=%d @0x%04x {regs=0x%04x %x}",
-                    vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
-                thisReg = vdst & 0x0f;
-            }
+            ILOGV("|invoke-super args=%d @0x%04x {regs=0x%04x %x}",
+                vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
+            thisReg = vdst & 0x0f;
         }
 
         /* impossible in well-formed code, but we must check nevertheless */
@@ -1609,41 +1468,31 @@
     }
 GOTO_TARGET_END
 
-GOTO_TARGET(invokeInterface, bool methodCallRange, bool jumboFormat)
+GOTO_TARGET(invokeInterface, bool methodCallRange)
     {
         Object* thisPtr;
         ClassObject* thisClass;
 
         EXPORT_PC();
 
-        if (jumboFormat) {
-            ref = FETCH(1) | (u4)FETCH(2) << 16;  /* method ref */
-            vsrc1 = FETCH(3);                     /* count */
-            vdst = FETCH(4);                      /* first reg */
-            ADJUST_PC(2);     /* advance pc partially to make returns easier */
-            ILOGV("|invoke-interface/jumbo args=%d @0x%08x {regs=v%d-v%d}",
+        vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
+        ref = FETCH(1);             /* method ref */
+        vdst = FETCH(2);            /* 4 regs -or- first reg */
+
+        /*
+         * The object against which we are executing a method is always
+         * in the first argument.
+         */
+        if (methodCallRange) {
+            assert(vsrc1 > 0);
+            ILOGV("|invoke-interface-range args=%d @0x%04x {regs=v%d-v%d}",
                 vsrc1, ref, vdst, vdst+vsrc1-1);
             thisPtr = (Object*) GET_REGISTER(vdst);
         } else {
-            vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
-            ref = FETCH(1);             /* method ref */
-            vdst = FETCH(2);            /* 4 regs -or- first reg */
-
-            /*
-             * The object against which we are executing a method is always
-             * in the first argument.
-             */
-            if (methodCallRange) {
-                assert(vsrc1 > 0);
-                ILOGV("|invoke-interface-range args=%d @0x%04x {regs=v%d-v%d}",
-                    vsrc1, ref, vdst, vdst+vsrc1-1);
-                thisPtr = (Object*) GET_REGISTER(vdst);
-            } else {
-                assert((vsrc1>>4) > 0);
-                ILOGV("|invoke-interface args=%d @0x%04x {regs=0x%04x %x}",
-                    vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
-                thisPtr = (Object*) GET_REGISTER(vdst & 0x0f);
-            }
+            assert((vsrc1>>4) > 0);
+            ILOGV("|invoke-interface args=%d @0x%04x {regs=0x%04x %x}",
+                vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
+            thisPtr = (Object*) GET_REGISTER(vdst & 0x0f);
         }
 
         if (!checkForNull(thisPtr))
@@ -1651,7 +1500,6 @@
 
         thisClass = thisPtr->clazz;
 
-
         /*
          * Given a class and a method index, find the Method* with the
          * actual code we want to execute.
@@ -1671,34 +1519,24 @@
     }
 GOTO_TARGET_END
 
-GOTO_TARGET(invokeDirect, bool methodCallRange, bool jumboFormat)
+GOTO_TARGET(invokeDirect, bool methodCallRange)
     {
         u2 thisReg;
 
         EXPORT_PC();
 
-        if (jumboFormat) {
-            ref = FETCH(1) | (u4)FETCH(2) << 16;  /* method ref */
-            vsrc1 = FETCH(3);                     /* count */
-            vdst = FETCH(4);                      /* first reg */
-            ADJUST_PC(2);     /* advance pc partially to make returns easier */
-            ILOGV("|invoke-direct/jumbo args=%d @0x%08x {regs=v%d-v%d}",
+        vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
+        ref = FETCH(1);             /* method ref */
+        vdst = FETCH(2);            /* 4 regs -or- first reg */
+
+        if (methodCallRange) {
+            ILOGV("|invoke-direct-range args=%d @0x%04x {regs=v%d-v%d}",
                 vsrc1, ref, vdst, vdst+vsrc1-1);
             thisReg = vdst;
         } else {
-            vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
-            ref = FETCH(1);             /* method ref */
-            vdst = FETCH(2);            /* 4 regs -or- first reg */
-
-            if (methodCallRange) {
-                ILOGV("|invoke-direct-range args=%d @0x%04x {regs=v%d-v%d}",
-                    vsrc1, ref, vdst, vdst+vsrc1-1);
-                thisReg = vdst;
-            } else {
-                ILOGV("|invoke-direct args=%d @0x%04x {regs=0x%04x %x}",
-                    vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
-                thisReg = vdst & 0x0f;
-            }
+            ILOGV("|invoke-direct args=%d @0x%04x {regs=0x%04x %x}",
+                vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
+            thisReg = vdst & 0x0f;
         }
 
         if (!checkForNull((Object*) GET_REGISTER(thisReg)))
@@ -1717,28 +1555,19 @@
     }
 GOTO_TARGET_END
 
-GOTO_TARGET(invokeStatic, bool methodCallRange, bool jumboFormat)
+GOTO_TARGET(invokeStatic, bool methodCallRange)
     EXPORT_PC();
 
-    if (jumboFormat) {
-        ref = FETCH(1) | (u4)FETCH(2) << 16;  /* method ref */
-        vsrc1 = FETCH(3);                     /* count */
-        vdst = FETCH(4);                      /* first reg */
-        ADJUST_PC(2);     /* advance pc partially to make returns easier */
-        ILOGV("|invoke-static/jumbo args=%d @0x%08x {regs=v%d-v%d}",
-            vsrc1, ref, vdst, vdst+vsrc1-1);
-    } else {
-        vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
-        ref = FETCH(1);             /* method ref */
-        vdst = FETCH(2);            /* 4 regs -or- first reg */
+    vsrc1 = INST_AA(inst);      /* AA (count) or BA (count + arg 5) */
+    ref = FETCH(1);             /* method ref */
+    vdst = FETCH(2);            /* 4 regs -or- first reg */
 
-        if (methodCallRange)
-            ILOGV("|invoke-static-range args=%d @0x%04x {regs=v%d-v%d}",
-                vsrc1, ref, vdst, vdst+vsrc1-1);
-        else
-            ILOGV("|invoke-static args=%d @0x%04x {regs=0x%04x %x}",
-                vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
-    }
+    if (methodCallRange)
+        ILOGV("|invoke-static-range args=%d @0x%04x {regs=v%d-v%d}",
+            vsrc1, ref, vdst, vdst+vsrc1-1);
+    else
+        ILOGV("|invoke-static args=%d @0x%04x {regs=0x%04x %x}",
+            vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
 
     methodToCall = dvmDexGetResolvedMethod(methodClassDex, ref);
     if (methodToCall == NULL) {
@@ -1764,7 +1593,7 @@
     GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst);
 GOTO_TARGET_END
 
-GOTO_TARGET(invokeVirtualQuick, bool methodCallRange, bool jumboFormat)
+GOTO_TARGET(invokeVirtualQuick, bool methodCallRange)
     {
         Object* thisPtr;
 
@@ -1823,7 +1652,7 @@
     }
 GOTO_TARGET_END
 
-GOTO_TARGET(invokeSuperQuick, bool methodCallRange, bool jumboFormat)
+GOTO_TARGET(invokeSuperQuick, bool methodCallRange)
     {
         u2 thisReg;
 
@@ -1944,7 +1773,7 @@
         {
             FINISH(3);
         } else {
-            //LOGE("Unknown invoke instr %02x at %d",
+            //ALOGE("Unknown invoke instr %02x at %d",
             //    invokeInstr, (int) (pc - curMethod->insns));
             assert(false);
         }
@@ -1976,7 +1805,7 @@
         dvmAddTrackedAlloc(exception, self);
         dvmClearException(self);
 
-        LOGV("Handling exception %s at %s:%d",
+        ALOGV("Handling exception %s at %s:%d",
             exception->clazz->descriptor, curMethod->name,
             dvmLineNumFromPC(curMethod, pc - curMethod->insns));
 
@@ -2044,7 +1873,7 @@
         if (catchRelPc < 0) {
             /* falling through to JNI code or off the bottom of the stack */
 #if DVM_SHOW_EXCEPTION >= 2
-            LOGD("Exception %s from %s:%d not caught locally",
+            ALOGD("Exception %s from %s:%d not caught locally",
                 exception->clazz->descriptor, dvmGetMethodSourceFile(curMethod),
                 dvmLineNumFromPC(curMethod, pc - curMethod->insns));
 #endif
@@ -2056,7 +1885,7 @@
 #if DVM_SHOW_EXCEPTION >= 3
         {
             const Method* catchMethod = SAVEAREA_FROM_FP(fp)->method;
-            LOGD("Exception %s thrown from %s:%d to %s:%d",
+            ALOGD("Exception %s thrown from %s:%d to %s:%d",
                 exception->clazz->descriptor, dvmGetMethodSourceFile(curMethod),
                 dvmLineNumFromPC(curMethod, pc - curMethod->insns),
                 dvmGetMethodSourceFile(catchMethod),
@@ -2206,7 +2035,7 @@
             bottom = (u1*) newSaveArea - methodToCall->outsSize * sizeof(u4);
             if (bottom < self->interpStackEnd) {
                 /* stack overflow */
-                LOGV("Stack overflow on method call (start=%p end=%p newBot=%p(%d) size=%d '%s')",
+                ALOGV("Stack overflow on method call (start=%p end=%p newBot=%p(%d) size=%d '%s')",
                     self->interpStackStart, self->interpStackEnd, bottom,
                     (u1*) fp - bottom, self->interpStackSize,
                     methodToCall->name);
@@ -2214,7 +2043,7 @@
                 assert(dvmCheckException(self));
                 GOTO_exceptionThrown();
             }
-            //LOGD("+++ fp=%p newFp=%p newSave=%p bottom=%p",
+            //ALOGD("+++ fp=%p newFp=%p newSave=%p bottom=%p",
             //    fp, newFp, newSaveArea, bottom);
         }
 
@@ -2260,8 +2089,8 @@
             self->interpSave.method = curMethod;
             methodClassDex = curMethod->clazz->pDvmDex;
             pc = methodToCall->insns;
-            self->interpSave.curFrame = newFp;
             fp = newFp;
+            self->interpSave.curFrame = fp;
 #ifdef EASY_GDB
             debugSaveArea = SAVEAREA_FROM_FP(newFp);
 #endif
@@ -2307,7 +2136,7 @@
              * it, jump to our local exception handling.
              */
             if (dvmCheckException(self)) {
-                LOGV("Exception thrown by/below native code");
+                ALOGV("Exception thrown by/below native code");
                 GOTO_exceptionThrown();
             }
 
@@ -2323,7 +2152,7 @@
             {
                 FINISH(3);
             } else {
-                //LOGE("Unknown invoke instr %02x at %d",
+                //ALOGE("Unknown invoke instr %02x at %d",
                 //    invokeInstr, (int) (pc - curMethod->insns));
                 assert(false);
             }