Move dx.dex.code.DalvOps -> dx.io.Opcodes.

This breaks a nascent circular dependency, keeping dx.io the lower layer.

Bonus: While I was in the territory, I clarified the data payload
opcodes, including adding explicit constants for them.

Change-Id: I8655064ebc3b5713cbb4a6c83bcc90984393701f

17 files changed, 1026 insertions, 1004 deletions

diff --git a/docs/dalvik-bytecode.html b/docs/dalvik-bytecode.html
index 19931d463..15294e8a0 100644
--- a/docs/dalvik-bytecode.html
+++ b/docs/dalvik-bytecode.html
@@ -68,7 +68,8 @@
   (after the operation).
 </li>
 <li>There are several "pseudo-instructions" that are used to hold
-  variable-length data referred to by regular instructions (for example,
+  variable-length data payloads, which are referred to by regular
+  instructions (for example,
   <code>fill-array-data</code>). Such instructions must never be
   encountered during the normal flow of execution. In addition, the
   instructions must be located on even-numbered bytecode offsets (that is,
@@ -164,9 +165,9 @@
     <p><b>Note:</b>
     Data-bearing pseudo-instructions are tagged with this opcode, in which
     case the high-order byte of the opcode unit indicates the nature of
-    the data. See "<code>packed-switch</code> Format",
-    "<code>sparse-switch</code> Format", and
-    "<code>fill-array-data</code> Format" below.</p>
+    the data. See "<code>packed-switch-payload</code> Format",
+    "<code>sparse-switch-payload</code> Format", and
+    "<code>fill-array-data-payload</code> Format" below.</p>
   </td>
 </tr>
 <tr>
@@ -509,7 +510,7 @@
 <tr>
   <td>26 31t</td>
   <td>fill-array-data vAA, +BBBBBBBB <i>(with supplemental data as specified
-    below in "<code>fill-array-data</code> Format")</i></td>
+    below in "<code>fill-array-data-payload</code> Format")</i></td>
   <td><code>A:</code> array reference (8 bits)<br/>
     <code>B:</code> signed "branch" offset to table data pseudo-instruction
     (32 bits)
@@ -558,7 +559,7 @@
 <tr>
   <td>2b 31t</td>
   <td>packed-switch vAA, +BBBBBBBB <i>(with supplemental data as
-    specified below in "<code>packed-switch</code> Format")</i></td>
+    specified below in "<code>packed-switch-payload</code> Format")</i></td>
   <td><code>A:</code> register to test<br/>
     <code>B:</code> signed "branch" offset to table data pseudo-instruction
     (32 bits)
@@ -572,7 +573,7 @@
 <tr>
   <td>2c 31t</td>
   <td>sparse-switch vAA, +BBBBBBBB <i>(with supplemental data as
-    specified below in "<code>sparse-switch</code> Format")</i></td>
+    specified below in "<code>sparse-switch-payload</code> Format")</i></td>
   <td><code>A:</code> register to test<br/>
     <code>B:</code> signed "branch" offset to table data pseudo-instruction
     (32 bits)
@@ -1134,7 +1135,7 @@
 </tbody>
 </table>
 
-<h2><code>packed-switch</code> Format</h2>
+<h2><code>packed-switch-payload</code> Format</h2>
 
 <table class="supplement">
 <thead>
@@ -1173,7 +1174,7 @@
 <p><b>Note:</b> The total number of code units for an instance of this
 table is <code>(size * 2) + 4</code>.</p>
 
-<h2><code>sparse-switch</code> Format</h2>
+<h2><code>sparse-switch-payload</code> Format</h2>
 
 <table class="supplement">
 <thead>
@@ -1213,7 +1214,7 @@ table is <code>(size * 2) + 4</code>.</p>
 <p><b>Note:</b> The total number of code units for an instance of this
 table is <code>(size * 4) + 2</code>.</p>
 
-<h2><code>fill-array-data</code> Format</h2>
+<h2><code>fill-array-data-payload</code> Format</h2>
 
 <table class="supplement">
 <thead>
diff --git a/dx/src/com/android/dx/dex/code/ArrayData.java b/dx/src/com/android/dx/dex/code/ArrayData.java
index 145f2c223..6674b7553 100644
--- a/dx/src/com/android/dx/dex/code/ArrayData.java
+++ b/dx/src/com/android/dx/dex/code/ArrayData.java
@@ -16,6 +16,7 @@
 
 package com.android.dx.dex.code;
 
+import com.android.dx.io.Opcodes;
 import com.android.dx.rop.code.RegisterSpecList;
 import com.android.dx.rop.code.SourcePosition;
 import com.android.dx.rop.cst.*;
@@ -109,7 +110,7 @@ public final class ArrayData extends VariableSizeInsn {
     public void writeTo(AnnotatedOutput out) {
         int sz = values.size();
 
-        out.writeShort(0x300 | DalvOps.NOP);
+        out.writeShort(Opcodes.FILL_ARRAY_DATA_PAYLOAD);
         out.writeShort(elemWidth);
         out.writeInt(initLength);
 
@@ -183,7 +184,7 @@ public final class ArrayData extends VariableSizeInsn {
         StringBuffer sb = new StringBuffer(100);
         int sz = values.size();
 
-        sb.append("array-data // for fill-array-data @ ");
+        sb.append("fill-array-data-payload // for fill-array-data @ ");
         sb.append(Hex.u2(baseAddress));
 
         for (int i = 0; i < sz; i++) {
diff --git a/dx/src/com/android/dx/dex/code/DalvInsnList.java b/dx/src/com/android/dx/dex/code/DalvInsnList.java
index 0f8c23d99..e856cb4bc 100644
--- a/dx/src/com/android/dx/dex/code/DalvInsnList.java
+++ b/dx/src/com/android/dx/dex/code/DalvInsnList.java
@@ -16,6 +16,7 @@
 
 package com.android.dx.dex.code;
 
+import com.android.dx.io.Opcodes;
 import com.android.dx.rop.cst.Constant;
 import com.android.dx.rop.cst.CstBaseMethodRef;
 import com.android.dx.util.AnnotatedOutput;
@@ -201,7 +202,7 @@ public final class DalvInsnList extends FixedSizeList {
             }
 
             boolean isStatic =
-                (insn.getOpcode().getFamily() == DalvOps.INVOKE_STATIC);
+                (insn.getOpcode().getFamily() == Opcodes.INVOKE_STATIC);
             int count =
                 ((CstBaseMethodRef) cst).getParameterWordCount(isStatic);
 
diff --git a/dx/src/com/android/dx/dex/code/Dop.java b/dx/src/com/android/dx/dex/code/Dop.java
index 565d8f9d0..a7c8397e3 100644
--- a/dx/src/com/android/dx/dex/code/Dop.java
+++ b/dx/src/com/android/dx/dex/code/Dop.java
@@ -16,20 +16,22 @@
 
 package com.android.dx.dex.code;
 
+import com.android.dx.io.Opcodes;
+
 /**
  * Representation of an opcode.
  */
 public final class Dop {
-    /** {@code DalvOps.isValid();} the opcode value itself */
+    /** {@code Opcodes.isValid();} the opcode value itself */
     private final int opcode;
 
-    /** {@code DalvOps.isValid();} the opcode family */
+    /** {@code Opcodes.isValid();} the opcode family */
     private final int family;
 
     /**
-     * {@code DalvOps.isValid();} what opcode (by number) to try next
+     * {@code Opcodes.isValid();} what opcode (by number) to try next
      * when attempting to match an opcode to particular arguments;
-     * {@code DalvOps.NO_NEXT} to indicate that this is the last
+     * {@code Opcodes.NO_NEXT} to indicate that this is the last
      * opcode to try in a particular chain
      */
     private final int nextOpcode;
@@ -46,12 +48,12 @@ public final class Dop {
     /**
      * Constructs an instance.
      *
-     * @param opcode {@code DalvOps.isValid();} the opcode value
+     * @param opcode {@code Opcodes.isValid();} the opcode value
      * itself
-     * @param family {@code DalvOps.isValid();} the opcode family
-     * @param nextOpcode {@code DalvOps.isValid();} what opcode (by
+     * @param family {@code Opcodes.isValid();} the opcode family
+     * @param nextOpcode {@code Opcodes.isValid();} what opcode (by
      * number) to try next when attempting to match an opcode to
-     * particular arguments; {@code DalvOps.NO_NEXT} to indicate that
+     * particular arguments; {@code Opcodes.NO_NEXT} to indicate that
      * this is the last opcode to try in a particular chain
      * @param format {@code non-null;} the instruction format
      * @param hasResult whether the opcode has a result register; if so it
@@ -60,15 +62,15 @@ public final class Dop {
      */
     public Dop(int opcode, int family, int nextOpcode, InsnFormat format,
             boolean hasResult, String name) {
-        if (!DalvOps.isValidShape(opcode)) {
+        if (!Opcodes.isValidShape(opcode)) {
             throw new IllegalArgumentException("bogus opcode");
         }
 
-        if (!DalvOps.isValidShape(family)) {
+        if (!Opcodes.isValidShape(family)) {
             throw new IllegalArgumentException("bogus family");
         }
 
-        if (!DalvOps.isValidShape(nextOpcode)) {
+        if (!Opcodes.isValidShape(nextOpcode)) {
             throw new IllegalArgumentException("bogus nextOpcode");
         }
 
@@ -97,7 +99,7 @@ public final class Dop {
     /**
      * Gets the opcode value.
      *
-     * @return {@code DalvOps.MIN_VALUE..DalvOps.MAX_VALUE;} the opcode value
+     * @return {@code Opcodes.MIN_VALUE..Opcodes.MAX_VALUE;} the opcode value
      */
     public int getOpcode() {
         return opcode;
@@ -107,7 +109,7 @@ public final class Dop {
      * Gets the opcode family. The opcode family is the unmarked (no
      * "/...") opcode that has equivalent semantics to this one.
      *
-     * @return {@code DalvOps.MIN_VALUE..DalvOps.MAX_VALUE;} the opcode family
+     * @return {@code Opcodes.MIN_VALUE..Opcodes.MAX_VALUE;} the opcode family
      */
     public int getFamily() {
         return family;
@@ -143,10 +145,10 @@ public final class Dop {
     /**
      * Gets the opcode value to try next when attempting to match an
      * opcode to particular arguments. This returns {@code
-     * DalvOps.NO_NEXT} to indicate that this is the last opcode to
+     * Opcodes.NO_NEXT} to indicate that this is the last opcode to
      * try in a particular chain.
      *
-     * @return {@code DalvOps.MIN_VALUE..DalvOps.MAX_VALUE;} the opcode value
+     * @return {@code Opcodes.MIN_VALUE..Opcodes.MAX_VALUE;} the opcode value
      */
     public int getNextOpcode() {
         return nextOpcode;
@@ -160,18 +162,18 @@ public final class Dop {
      */
     public Dop getOppositeTest() {
         switch (opcode) {
-            case DalvOps.IF_EQ:  return Dops.IF_NE;
-            case DalvOps.IF_NE:  return Dops.IF_EQ;
-            case DalvOps.IF_LT:  return Dops.IF_GE;
-            case DalvOps.IF_GE:  return Dops.IF_LT;
-            case DalvOps.IF_GT:  return Dops.IF_LE;
-            case DalvOps.IF_LE:  return Dops.IF_GT;
-            case DalvOps.IF_EQZ: return Dops.IF_NEZ;
-            case DalvOps.IF_NEZ: return Dops.IF_EQZ;
-            case DalvOps.IF_LTZ: return Dops.IF_GEZ;
-            case DalvOps.IF_GEZ: return Dops.IF_LTZ;
-            case DalvOps.IF_GTZ: return Dops.IF_LEZ;
-            case DalvOps.IF_LEZ: return Dops.IF_GTZ;
+            case Opcodes.IF_EQ:  return Dops.IF_NE;
+            case Opcodes.IF_NE:  return Dops.IF_EQ;
+            case Opcodes.IF_LT:  return Dops.IF_GE;
+            case Opcodes.IF_GE:  return Dops.IF_LT;
+            case Opcodes.IF_GT:  return Dops.IF_LE;
+            case Opcodes.IF_LE:  return Dops.IF_GT;
+            case Opcodes.IF_EQZ: return Dops.IF_NEZ;
+            case Opcodes.IF_NEZ: return Dops.IF_EQZ;
+            case Opcodes.IF_LTZ: return Dops.IF_GEZ;
+            case Opcodes.IF_GEZ: return Dops.IF_LTZ;
+            case Opcodes.IF_GTZ: return Dops.IF_LEZ;
+            case Opcodes.IF_LEZ: return Dops.IF_GTZ;
         }
 
         throw new IllegalArgumentException("bogus opcode: " + this);
diff --git a/dx/src/com/android/dx/dex/code/Dops.java b/dx/src/com/android/dx/dex/code/Dops.java
index 053f47b6d..a19b02b39 100644
--- a/dx/src/com/android/dx/dex/code/Dops.java
+++ b/dx/src/com/android/dx/dex/code/Dops.java
@@ -44,6 +44,7 @@ import com.android.dx.dex.code.form.Form51l;
 import com.android.dx.dex.code.form.Form52c;
 import com.android.dx.dex.code.form.Form5rc;
 import com.android.dx.dex.code.form.SpecialFormat;
+import com.android.dx.io.Opcodes;
 
 /**
  * Standard instances of {@link Dop} and utility methods for getting
@@ -59,1300 +60,1300 @@ public final class Dops {
      * appear in instruction lists)
      */
     public static final Dop SPECIAL_FORMAT =
-        new Dop(DalvOps.SPECIAL_FORMAT, DalvOps.SPECIAL_FORMAT,
-                DalvOps.NO_NEXT, SpecialFormat.THE_ONE, false, "<special>");
+        new Dop(Opcodes.SPECIAL_FORMAT, Opcodes.SPECIAL_FORMAT,
+                Opcodes.NO_NEXT, SpecialFormat.THE_ONE, false, "<special>");
 
     // BEGIN(dops); GENERATED AUTOMATICALLY BY opcode-gen
     public static final Dop NOP =
-        new Dop(DalvOps.NOP, DalvOps.NOP,
-            DalvOps.NO_NEXT, Form10x.THE_ONE, false,
+        new Dop(Opcodes.NOP, Opcodes.NOP,
+            Opcodes.NO_NEXT, Form10x.THE_ONE, false,
             "nop");
 
     public static final Dop MOVE =
-        new Dop(DalvOps.MOVE, DalvOps.MOVE,
-            DalvOps.MOVE_FROM16, Form12x.THE_ONE, true,
+        new Dop(Opcodes.MOVE, Opcodes.MOVE,
+            Opcodes.MOVE_FROM16, Form12x.THE_ONE, true,
             "move");
 
     public static final Dop MOVE_FROM16 =
-        new Dop(DalvOps.MOVE_FROM16, DalvOps.MOVE,
-            DalvOps.MOVE_16, Form22x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_FROM16, Opcodes.MOVE,
+            Opcodes.MOVE_16, Form22x.THE_ONE, true,
             "move/from16");
 
     public static final Dop MOVE_16 =
-        new Dop(DalvOps.MOVE_16, DalvOps.MOVE,
-            DalvOps.NO_NEXT, Form32x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_16, Opcodes.MOVE,
+            Opcodes.NO_NEXT, Form32x.THE_ONE, true,
             "move/16");
 
     public static final Dop MOVE_WIDE =
-        new Dop(DalvOps.MOVE_WIDE, DalvOps.MOVE_WIDE,
-            DalvOps.MOVE_WIDE_FROM16, Form12x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_WIDE, Opcodes.MOVE_WIDE,
+            Opcodes.MOVE_WIDE_FROM16, Form12x.THE_ONE, true,
             "move-wide");
 
     public static final Dop MOVE_WIDE_FROM16 =
-        new Dop(DalvOps.MOVE_WIDE_FROM16, DalvOps.MOVE_WIDE,
-            DalvOps.MOVE_WIDE_16, Form22x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_WIDE_FROM16, Opcodes.MOVE_WIDE,
+            Opcodes.MOVE_WIDE_16, Form22x.THE_ONE, true,
             "move-wide/from16");
 
     public static final Dop MOVE_WIDE_16 =
-        new Dop(DalvOps.MOVE_WIDE_16, DalvOps.MOVE_WIDE,
-            DalvOps.NO_NEXT, Form32x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_WIDE_16, Opcodes.MOVE_WIDE,
+            Opcodes.NO_NEXT, Form32x.THE_ONE, true,
             "move-wide/16");
 
     public static final Dop MOVE_OBJECT =
-        new Dop(DalvOps.MOVE_OBJECT, DalvOps.MOVE_OBJECT,
-            DalvOps.MOVE_OBJECT_FROM16, Form12x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_OBJECT, Opcodes.MOVE_OBJECT,
+            Opcodes.MOVE_OBJECT_FROM16, Form12x.THE_ONE, true,
             "move-object");
 
     public static final Dop MOVE_OBJECT_FROM16 =
-        new Dop(DalvOps.MOVE_OBJECT_FROM16, DalvOps.MOVE_OBJECT,
-            DalvOps.MOVE_OBJECT_16, Form22x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_OBJECT_FROM16, Opcodes.MOVE_OBJECT,
+            Opcodes.MOVE_OBJECT_16, Form22x.THE_ONE, true,
             "move-object/from16");
 
     public static final Dop MOVE_OBJECT_16 =
-        new Dop(DalvOps.MOVE_OBJECT_16, DalvOps.MOVE_OBJECT,
-            DalvOps.NO_NEXT, Form32x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_OBJECT_16, Opcodes.MOVE_OBJECT,
+            Opcodes.NO_NEXT, Form32x.THE_ONE, true,
             "move-object/16");
 
     public static final Dop MOVE_RESULT =
-        new Dop(DalvOps.MOVE_RESULT, DalvOps.MOVE_RESULT,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_RESULT, Opcodes.MOVE_RESULT,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, true,
             "move-result");
 
     public static final Dop MOVE_RESULT_WIDE =
-        new Dop(DalvOps.MOVE_RESULT_WIDE, DalvOps.MOVE_RESULT_WIDE,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_RESULT_WIDE, Opcodes.MOVE_RESULT_WIDE,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, true,
             "move-result-wide");
 
     public static final Dop MOVE_RESULT_OBJECT =
-        new Dop(DalvOps.MOVE_RESULT_OBJECT, DalvOps.MOVE_RESULT_OBJECT,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_RESULT_OBJECT, Opcodes.MOVE_RESULT_OBJECT,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, true,
             "move-result-object");
 
     public static final Dop MOVE_EXCEPTION =
-        new Dop(DalvOps.MOVE_EXCEPTION, DalvOps.MOVE_EXCEPTION,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, true,
+        new Dop(Opcodes.MOVE_EXCEPTION, Opcodes.MOVE_EXCEPTION,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, true,
             "move-exception");
 
     public static final Dop RETURN_VOID =
-        new Dop(DalvOps.RETURN_VOID, DalvOps.RETURN_VOID,
-            DalvOps.NO_NEXT, Form10x.THE_ONE, false,
+        new Dop(Opcodes.RETURN_VOID, Opcodes.RETURN_VOID,
+            Opcodes.NO_NEXT, Form10x.THE_ONE, false,
             "return-void");
 
     public static final Dop RETURN =
-        new Dop(DalvOps.RETURN, DalvOps.RETURN,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, false,
+        new Dop(Opcodes.RETURN, Opcodes.RETURN,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, false,
             "return");
 
     public static final Dop RETURN_WIDE =
-        new Dop(DalvOps.RETURN_WIDE, DalvOps.RETURN_WIDE,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, false,
+        new Dop(Opcodes.RETURN_WIDE, Opcodes.RETURN_WIDE,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, false,
             "return-wide");
 
     public static final Dop RETURN_OBJECT =
-        new Dop(DalvOps.RETURN_OBJECT, DalvOps.RETURN_OBJECT,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, false,
+        new Dop(Opcodes.RETURN_OBJECT, Opcodes.RETURN_OBJECT,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, false,
             "return-object");
 
     public static final Dop CONST_4 =
-        new Dop(DalvOps.CONST_4, DalvOps.CONST,
-            DalvOps.CONST_16, Form11n.THE_ONE, true,
+        new Dop(Opcodes.CONST_4, Opcodes.CONST,
+            Opcodes.CONST_16, Form11n.THE_ONE, true,
             "const/4");
 
     public static final Dop CONST_16 =
-        new Dop(DalvOps.CONST_16, DalvOps.CONST,
-            DalvOps.CONST_HIGH16, Form21s.THE_ONE, true,
+        new Dop(Opcodes.CONST_16, Opcodes.CONST,
+            Opcodes.CONST_HIGH16, Form21s.THE_ONE, true,
             "const/16");
 
     public static final Dop CONST =
-        new Dop(DalvOps.CONST, DalvOps.CONST,
-            DalvOps.NO_NEXT, Form31i.THE_ONE, true,
+        new Dop(Opcodes.CONST, Opcodes.CONST,
+            Opcodes.NO_NEXT, Form31i.THE_ONE, true,
             "const");
 
     public static final Dop CONST_HIGH16 =
-        new Dop(DalvOps.CONST_HIGH16, DalvOps.CONST,
-            DalvOps.CONST, Form21h.THE_ONE, true,
+        new Dop(Opcodes.CONST_HIGH16, Opcodes.CONST,
+            Opcodes.CONST, Form21h.THE_ONE, true,
             "const/high16");
 
     public static final Dop CONST_WIDE_16 =
-        new Dop(DalvOps.CONST_WIDE_16, DalvOps.CONST_WIDE,
-            DalvOps.CONST_WIDE_HIGH16, Form21s.THE_ONE, true,
+        new Dop(Opcodes.CONST_WIDE_16, Opcodes.CONST_WIDE,
+            Opcodes.CONST_WIDE_HIGH16, Form21s.THE_ONE, true,
             "const-wide/16");
 
     public static final Dop CONST_WIDE_32 =
-        new Dop(DalvOps.CONST_WIDE_32, DalvOps.CONST_WIDE,
-            DalvOps.CONST_WIDE, Form31i.THE_ONE, true,
+        new Dop(Opcodes.CONST_WIDE_32, Opcodes.CONST_WIDE,
+            Opcodes.CONST_WIDE, Form31i.THE_ONE, true,
             "const-wide/32");
 
     public static final Dop CONST_WIDE =
-        new Dop(DalvOps.CONST_WIDE, DalvOps.CONST_WIDE,
-            DalvOps.NO_NEXT, Form51l.THE_ONE, true,
+        new Dop(Opcodes.CONST_WIDE, Opcodes.CONST_WIDE,
+            Opcodes.NO_NEXT, Form51l.THE_ONE, true,
             "const-wide");
 
     public static final Dop CONST_WIDE_HIGH16 =
-        new Dop(DalvOps.CONST_WIDE_HIGH16, DalvOps.CONST_WIDE,
-            DalvOps.CONST_WIDE_32, Form21h.THE_ONE, true,
+        new Dop(Opcodes.CONST_WIDE_HIGH16, Opcodes.CONST_WIDE,
+            Opcodes.CONST_WIDE_32, Form21h.THE_ONE, true,
             "const-wide/high16");
 
     public static final Dop CONST_STRING =
-        new Dop(DalvOps.CONST_STRING, DalvOps.CONST_STRING,
-            DalvOps.CONST_STRING_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.CONST_STRING, Opcodes.CONST_STRING,
+            Opcodes.CONST_STRING_JUMBO, Form21c.THE_ONE, true,
             "const-string");
 
     public static final Dop CONST_STRING_JUMBO =
-        new Dop(DalvOps.CONST_STRING_JUMBO, DalvOps.CONST_STRING,
-            DalvOps.NO_NEXT, Form31c.THE_ONE, true,
+        new Dop(Opcodes.CONST_STRING_JUMBO, Opcodes.CONST_STRING,
+            Opcodes.NO_NEXT, Form31c.THE_ONE, true,
             "const-string/jumbo");
 
     public static final Dop CONST_CLASS =
-        new Dop(DalvOps.CONST_CLASS, DalvOps.CONST_CLASS,
-            DalvOps.CONST_CLASS_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.CONST_CLASS, Opcodes.CONST_CLASS,
+            Opcodes.CONST_CLASS_JUMBO, Form21c.THE_ONE, true,
             "const-class");
 
     public static final Dop MONITOR_ENTER =
-        new Dop(DalvOps.MONITOR_ENTER, DalvOps.MONITOR_ENTER,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, false,
+        new Dop(Opcodes.MONITOR_ENTER, Opcodes.MONITOR_ENTER,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, false,
             "monitor-enter");
 
     public static final Dop MONITOR_EXIT =
-        new Dop(DalvOps.MONITOR_EXIT, DalvOps.MONITOR_EXIT,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, false,
+        new Dop(Opcodes.MONITOR_EXIT, Opcodes.MONITOR_EXIT,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, false,
             "monitor-exit");
 
     public static final Dop CHECK_CAST =
-        new Dop(DalvOps.CHECK_CAST, DalvOps.CHECK_CAST,
-            DalvOps.CHECK_CAST_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.CHECK_CAST, Opcodes.CHECK_CAST,
+            Opcodes.CHECK_CAST_JUMBO, Form21c.THE_ONE, true,
             "check-cast");
 
     public static final Dop INSTANCE_OF =
-        new Dop(DalvOps.INSTANCE_OF, DalvOps.INSTANCE_OF,
-            DalvOps.INSTANCE_OF_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.INSTANCE_OF, Opcodes.INSTANCE_OF,
+            Opcodes.INSTANCE_OF_JUMBO, Form22c.THE_ONE, true,
             "instance-of");
 
     public static final Dop ARRAY_LENGTH =
-        new Dop(DalvOps.ARRAY_LENGTH, DalvOps.ARRAY_LENGTH,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.ARRAY_LENGTH, Opcodes.ARRAY_LENGTH,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "array-length");
 
     public static final Dop NEW_INSTANCE =
-        new Dop(DalvOps.NEW_INSTANCE, DalvOps.NEW_INSTANCE,
-            DalvOps.NEW_INSTANCE_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.NEW_INSTANCE, Opcodes.NEW_INSTANCE,
+            Opcodes.NEW_INSTANCE_JUMBO, Form21c.THE_ONE, true,
             "new-instance");
 
     public static final Dop NEW_ARRAY =
-        new Dop(DalvOps.NEW_ARRAY, DalvOps.NEW_ARRAY,
-            DalvOps.NEW_ARRAY_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.NEW_ARRAY, Opcodes.NEW_ARRAY,
+            Opcodes.NEW_ARRAY_JUMBO, Form22c.THE_ONE, true,
             "new-array");
 
     public static final Dop FILLED_NEW_ARRAY =
-        new Dop(DalvOps.FILLED_NEW_ARRAY, DalvOps.FILLED_NEW_ARRAY,
-            DalvOps.FILLED_NEW_ARRAY_RANGE, Form35c.THE_ONE, false,
+        new Dop(Opcodes.FILLED_NEW_ARRAY, Opcodes.FILLED_NEW_ARRAY,
+            Opcodes.FILLED_NEW_ARRAY_RANGE, Form35c.THE_ONE, false,
             "filled-new-array");
 
     public static final Dop FILLED_NEW_ARRAY_RANGE =
-        new Dop(DalvOps.FILLED_NEW_ARRAY_RANGE, DalvOps.FILLED_NEW_ARRAY,
-            DalvOps.FILLED_NEW_ARRAY_JUMBO, Form3rc.THE_ONE, false,
+        new Dop(Opcodes.FILLED_NEW_ARRAY_RANGE, Opcodes.FILLED_NEW_ARRAY,
+            Opcodes.FILLED_NEW_ARRAY_JUMBO, Form3rc.THE_ONE, false,
             "filled-new-array/range");
 
     public static final Dop FILL_ARRAY_DATA =
-        new Dop(DalvOps.FILL_ARRAY_DATA, DalvOps.FILL_ARRAY_DATA,
-            DalvOps.NO_NEXT, Form31t.THE_ONE, false,
+        new Dop(Opcodes.FILL_ARRAY_DATA, Opcodes.FILL_ARRAY_DATA,
+            Opcodes.NO_NEXT, Form31t.THE_ONE, false,
             "fill-array-data");
 
     public static final Dop THROW =
-        new Dop(DalvOps.THROW, DalvOps.THROW,
-            DalvOps.NO_NEXT, Form11x.THE_ONE, false,
+        new Dop(Opcodes.THROW, Opcodes.THROW,
+            Opcodes.NO_NEXT, Form11x.THE_ONE, false,
             "throw");
 
     public static final Dop GOTO =
-        new Dop(DalvOps.GOTO, DalvOps.GOTO,
-            DalvOps.GOTO_16, Form10t.THE_ONE, false,
+        new Dop(Opcodes.GOTO, Opcodes.GOTO,
+            Opcodes.GOTO_16, Form10t.THE_ONE, false,
             "goto");
 
     public static final Dop GOTO_16 =
-        new Dop(DalvOps.GOTO_16, DalvOps.GOTO,
-            DalvOps.GOTO_32, Form20t.THE_ONE, false,
+        new Dop(Opcodes.GOTO_16, Opcodes.GOTO,
+            Opcodes.GOTO_32, Form20t.THE_ONE, false,
             "goto/16");
 
     public static final Dop GOTO_32 =
-        new Dop(DalvOps.GOTO_32, DalvOps.GOTO,
-            DalvOps.NO_NEXT, Form30t.THE_ONE, false,
+        new Dop(Opcodes.GOTO_32, Opcodes.GOTO,
+            Opcodes.NO_NEXT, Form30t.THE_ONE, false,
             "goto/32");
 
     public static final Dop PACKED_SWITCH =
-        new Dop(DalvOps.PACKED_SWITCH, DalvOps.PACKED_SWITCH,
-            DalvOps.NO_NEXT, Form31t.THE_ONE, false,
+        new Dop(Opcodes.PACKED_SWITCH, Opcodes.PACKED_SWITCH,
+            Opcodes.NO_NEXT, Form31t.THE_ONE, false,
             "packed-switch");
 
     public static final Dop SPARSE_SWITCH =
-        new Dop(DalvOps.SPARSE_SWITCH, DalvOps.SPARSE_SWITCH,
-            DalvOps.NO_NEXT, Form31t.THE_ONE, false,
+        new Dop(Opcodes.SPARSE_SWITCH, Opcodes.SPARSE_SWITCH,
+            Opcodes.NO_NEXT, Form31t.THE_ONE, false,
             "sparse-switch");
 
     public static final Dop CMPL_FLOAT =
-        new Dop(DalvOps.CMPL_FLOAT, DalvOps.CMPL_FLOAT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.CMPL_FLOAT, Opcodes.CMPL_FLOAT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "cmpl-float");
 
     public static final Dop CMPG_FLOAT =
-        new Dop(DalvOps.CMPG_FLOAT, DalvOps.CMPG_FLOAT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.CMPG_FLOAT, Opcodes.CMPG_FLOAT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "cmpg-float");
 
     public static final Dop CMPL_DOUBLE =
-        new Dop(DalvOps.CMPL_DOUBLE, DalvOps.CMPL_DOUBLE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.CMPL_DOUBLE, Opcodes.CMPL_DOUBLE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "cmpl-double");
 
     public static final Dop CMPG_DOUBLE =
-        new Dop(DalvOps.CMPG_DOUBLE, DalvOps.CMPG_DOUBLE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.CMPG_DOUBLE, Opcodes.CMPG_DOUBLE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "cmpg-double");
 
     public static final Dop CMP_LONG =
-        new Dop(DalvOps.CMP_LONG, DalvOps.CMP_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.CMP_LONG, Opcodes.CMP_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "cmp-long");
 
     public static final Dop IF_EQ =
-        new Dop(DalvOps.IF_EQ, DalvOps.IF_EQ,
-            DalvOps.NO_NEXT, Form22t.THE_ONE, false,
+        new Dop(Opcodes.IF_EQ, Opcodes.IF_EQ,
+            Opcodes.NO_NEXT, Form22t.THE_ONE, false,
             "if-eq");
 
     public static final Dop IF_NE =
-        new Dop(DalvOps.IF_NE, DalvOps.IF_NE,
-            DalvOps.NO_NEXT, Form22t.THE_ONE, false,
+        new Dop(Opcodes.IF_NE, Opcodes.IF_NE,
+            Opcodes.NO_NEXT, Form22t.THE_ONE, false,
             "if-ne");
 
     public static final Dop IF_LT =
-        new Dop(DalvOps.IF_LT, DalvOps.IF_LT,
-            DalvOps.NO_NEXT, Form22t.THE_ONE, false,
+        new Dop(Opcodes.IF_LT, Opcodes.IF_LT,
+            Opcodes.NO_NEXT, Form22t.THE_ONE, false,
             "if-lt");
 
     public static final Dop IF_GE =
-        new Dop(DalvOps.IF_GE, DalvOps.IF_GE,
-            DalvOps.NO_NEXT, Form22t.THE_ONE, false,
+        new Dop(Opcodes.IF_GE, Opcodes.IF_GE,
+            Opcodes.NO_NEXT, Form22t.THE_ONE, false,
             "if-ge");
 
     public static final Dop IF_GT =
-        new Dop(DalvOps.IF_GT, DalvOps.IF_GT,
-            DalvOps.NO_NEXT, Form22t.THE_ONE, false,
+        new Dop(Opcodes.IF_GT, Opcodes.IF_GT,
+            Opcodes.NO_NEXT, Form22t.THE_ONE, false,
             "if-gt");
 
     public static final Dop IF_LE =
-        new Dop(DalvOps.IF_LE, DalvOps.IF_LE,
-            DalvOps.NO_NEXT, Form22t.THE_ONE, false,
+        new Dop(Opcodes.IF_LE, Opcodes.IF_LE,
+            Opcodes.NO_NEXT, Form22t.THE_ONE, false,
             "if-le");
 
     public static final Dop IF_EQZ =
-        new Dop(DalvOps.IF_EQZ, DalvOps.IF_EQZ,
-            DalvOps.NO_NEXT, Form21t.THE_ONE, false,
+        new Dop(Opcodes.IF_EQZ, Opcodes.IF_EQZ,
+            Opcodes.NO_NEXT, Form21t.THE_ONE, false,
             "if-eqz");
 
     public static final Dop IF_NEZ =
-        new Dop(DalvOps.IF_NEZ, DalvOps.IF_NEZ,
-            DalvOps.NO_NEXT, Form21t.THE_ONE, false,
+        new Dop(Opcodes.IF_NEZ, Opcodes.IF_NEZ,
+            Opcodes.NO_NEXT, Form21t.THE_ONE, false,
             "if-nez");
 
     public static final Dop IF_LTZ =
-        new Dop(DalvOps.IF_LTZ, DalvOps.IF_LTZ,
-            DalvOps.NO_NEXT, Form21t.THE_ONE, false,
+        new Dop(Opcodes.IF_LTZ, Opcodes.IF_LTZ,
+            Opcodes.NO_NEXT, Form21t.THE_ONE, false,
             "if-ltz");
 
     public static final Dop IF_GEZ =
-        new Dop(DalvOps.IF_GEZ, DalvOps.IF_GEZ,
-            DalvOps.NO_NEXT, Form21t.THE_ONE, false,
+        new Dop(Opcodes.IF_GEZ, Opcodes.IF_GEZ,
+            Opcodes.NO_NEXT, Form21t.THE_ONE, false,
             "if-gez");
 
     public static final Dop IF_GTZ =
-        new Dop(DalvOps.IF_GTZ, DalvOps.IF_GTZ,
-            DalvOps.NO_NEXT, Form21t.THE_ONE, false,
+        new Dop(Opcodes.IF_GTZ, Opcodes.IF_GTZ,
+            Opcodes.NO_NEXT, Form21t.THE_ONE, false,
             "if-gtz");
 
     public static final Dop IF_LEZ =
-        new Dop(DalvOps.IF_LEZ, DalvOps.IF_LEZ,
-            DalvOps.NO_NEXT, Form21t.THE_ONE, false,
+        new Dop(Opcodes.IF_LEZ, Opcodes.IF_LEZ,
+            Opcodes.NO_NEXT, Form21t.THE_ONE, false,
             "if-lez");
 
     public static final Dop AGET =
-        new Dop(DalvOps.AGET, DalvOps.AGET,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AGET, Opcodes.AGET,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "aget");
 
     public static final Dop AGET_WIDE =
-        new Dop(DalvOps.AGET_WIDE, DalvOps.AGET_WIDE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AGET_WIDE, Opcodes.AGET_WIDE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "aget-wide");
 
     public static final Dop AGET_OBJECT =
-        new Dop(DalvOps.AGET_OBJECT, DalvOps.AGET_OBJECT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AGET_OBJECT, Opcodes.AGET_OBJECT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "aget-object");
 
     public static final Dop AGET_BOOLEAN =
-        new Dop(DalvOps.AGET_BOOLEAN, DalvOps.AGET_BOOLEAN,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AGET_BOOLEAN, Opcodes.AGET_BOOLEAN,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "aget-boolean");
 
     public static final Dop AGET_BYTE =
-        new Dop(DalvOps.AGET_BYTE, DalvOps.AGET_BYTE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AGET_BYTE, Opcodes.AGET_BYTE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "aget-byte");
 
     public static final Dop AGET_CHAR =
-        new Dop(DalvOps.AGET_CHAR, DalvOps.AGET_CHAR,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AGET_CHAR, Opcodes.AGET_CHAR,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "aget-char");
 
     public static final Dop AGET_SHORT =
-        new Dop(DalvOps.AGET_SHORT, DalvOps.AGET_SHORT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AGET_SHORT, Opcodes.AGET_SHORT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "aget-short");
 
     public static final Dop APUT =
-        new Dop(DalvOps.APUT, DalvOps.APUT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, false,
+        new Dop(Opcodes.APUT, Opcodes.APUT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, false,
             "aput");
 
     public static final Dop APUT_WIDE =
-        new Dop(DalvOps.APUT_WIDE, DalvOps.APUT_WIDE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, false,
+        new Dop(Opcodes.APUT_WIDE, Opcodes.APUT_WIDE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, false,
             "aput-wide");
 
     public static final Dop APUT_OBJECT =
-        new Dop(DalvOps.APUT_OBJECT, DalvOps.APUT_OBJECT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, false,
+        new Dop(Opcodes.APUT_OBJECT, Opcodes.APUT_OBJECT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, false,
             "aput-object");
 
     public static final Dop APUT_BOOLEAN =
-        new Dop(DalvOps.APUT_BOOLEAN, DalvOps.APUT_BOOLEAN,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, false,
+        new Dop(Opcodes.APUT_BOOLEAN, Opcodes.APUT_BOOLEAN,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, false,
             "aput-boolean");
 
     public static final Dop APUT_BYTE =
-        new Dop(DalvOps.APUT_BYTE, DalvOps.APUT_BYTE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, false,
+        new Dop(Opcodes.APUT_BYTE, Opcodes.APUT_BYTE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, false,
             "aput-byte");
 
     public static final Dop APUT_CHAR =
-        new Dop(DalvOps.APUT_CHAR, DalvOps.APUT_CHAR,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, false,
+        new Dop(Opcodes.APUT_CHAR, Opcodes.APUT_CHAR,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, false,
             "aput-char");
 
     public static final Dop APUT_SHORT =
-        new Dop(DalvOps.APUT_SHORT, DalvOps.APUT_SHORT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, false,
+        new Dop(Opcodes.APUT_SHORT, Opcodes.APUT_SHORT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, false,
             "aput-short");
 
     public static final Dop IGET =
-        new Dop(DalvOps.IGET, DalvOps.IGET,
-            DalvOps.IGET_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.IGET, Opcodes.IGET,
+            Opcodes.IGET_JUMBO, Form22c.THE_ONE, true,
             "iget");
 
     public static final Dop IGET_WIDE =
-        new Dop(DalvOps.IGET_WIDE, DalvOps.IGET_WIDE,
-            DalvOps.IGET_WIDE_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.IGET_WIDE, Opcodes.IGET_WIDE,
+            Opcodes.IGET_WIDE_JUMBO, Form22c.THE_ONE, true,
             "iget-wide");
 
     public static final Dop IGET_OBJECT =
-        new Dop(DalvOps.IGET_OBJECT, DalvOps.IGET_OBJECT,
-            DalvOps.IGET_OBJECT_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.IGET_OBJECT, Opcodes.IGET_OBJECT,
+            Opcodes.IGET_OBJECT_JUMBO, Form22c.THE_ONE, true,
             "iget-object");
 
     public static final Dop IGET_BOOLEAN =
-        new Dop(DalvOps.IGET_BOOLEAN, DalvOps.IGET_BOOLEAN,
-            DalvOps.IGET_BOOLEAN_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.IGET_BOOLEAN, Opcodes.IGET_BOOLEAN,
+            Opcodes.IGET_BOOLEAN_JUMBO, Form22c.THE_ONE, true,
             "iget-boolean");
 
     public static final Dop IGET_BYTE =
-        new Dop(DalvOps.IGET_BYTE, DalvOps.IGET_BYTE,
-            DalvOps.IGET_BYTE_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.IGET_BYTE, Opcodes.IGET_BYTE,
+            Opcodes.IGET_BYTE_JUMBO, Form22c.THE_ONE, true,
             "iget-byte");
 
     public static final Dop IGET_CHAR =
-        new Dop(DalvOps.IGET_CHAR, DalvOps.IGET_CHAR,
-            DalvOps.IGET_CHAR_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.IGET_CHAR, Opcodes.IGET_CHAR,
+            Opcodes.IGET_CHAR_JUMBO, Form22c.THE_ONE, true,
             "iget-char");
 
     public static final Dop IGET_SHORT =
-        new Dop(DalvOps.IGET_SHORT, DalvOps.IGET_SHORT,
-            DalvOps.IGET_SHORT_JUMBO, Form22c.THE_ONE, true,
+        new Dop(Opcodes.IGET_SHORT, Opcodes.IGET_SHORT,
+            Opcodes.IGET_SHORT_JUMBO, Form22c.THE_ONE, true,
             "iget-short");
 
     public static final Dop IPUT =
-        new Dop(DalvOps.IPUT, DalvOps.IPUT,
-            DalvOps.IPUT_JUMBO, Form22c.THE_ONE, false,
+        new Dop(Opcodes.IPUT, Opcodes.IPUT,
+            Opcodes.IPUT_JUMBO, Form22c.THE_ONE, false,
             "iput");
 
     public static final Dop IPUT_WIDE =
-        new Dop(DalvOps.IPUT_WIDE, DalvOps.IPUT_WIDE,
-            DalvOps.IPUT_WIDE_JUMBO, Form22c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_WIDE, Opcodes.IPUT_WIDE,
+            Opcodes.IPUT_WIDE_JUMBO, Form22c.THE_ONE, false,
             "iput-wide");
 
     public static final Dop IPUT_OBJECT =
-        new Dop(DalvOps.IPUT_OBJECT, DalvOps.IPUT_OBJECT,
-            DalvOps.IPUT_OBJECT_JUMBO, Form22c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_OBJECT, Opcodes.IPUT_OBJECT,
+            Opcodes.IPUT_OBJECT_JUMBO, Form22c.THE_ONE, false,
             "iput-object");
 
     public static final Dop IPUT_BOOLEAN =
-        new Dop(DalvOps.IPUT_BOOLEAN, DalvOps.IPUT_BOOLEAN,
-            DalvOps.IPUT_BOOLEAN_JUMBO, Form22c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_BOOLEAN, Opcodes.IPUT_BOOLEAN,
+            Opcodes.IPUT_BOOLEAN_JUMBO, Form22c.THE_ONE, false,
             "iput-boolean");
 
     public static final Dop IPUT_BYTE =
-        new Dop(DalvOps.IPUT_BYTE, DalvOps.IPUT_BYTE,
-            DalvOps.IPUT_BYTE_JUMBO, Form22c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_BYTE, Opcodes.IPUT_BYTE,
+            Opcodes.IPUT_BYTE_JUMBO, Form22c.THE_ONE, false,
             "iput-byte");
 
     public static final Dop IPUT_CHAR =
-        new Dop(DalvOps.IPUT_CHAR, DalvOps.IPUT_CHAR,
-            DalvOps.IPUT_CHAR_JUMBO, Form22c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_CHAR, Opcodes.IPUT_CHAR,
+            Opcodes.IPUT_CHAR_JUMBO, Form22c.THE_ONE, false,
             "iput-char");
 
     public static final Dop IPUT_SHORT =
-        new Dop(DalvOps.IPUT_SHORT, DalvOps.IPUT_SHORT,
-            DalvOps.IPUT_SHORT_JUMBO, Form22c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_SHORT, Opcodes.IPUT_SHORT,
+            Opcodes.IPUT_SHORT_JUMBO, Form22c.THE_ONE, false,
             "iput-short");
 
     public static final Dop SGET =
-        new Dop(DalvOps.SGET, DalvOps.SGET,
-            DalvOps.SGET_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.SGET, Opcodes.SGET,
+            Opcodes.SGET_JUMBO, Form21c.THE_ONE, true,
             "sget");
 
     public static final Dop SGET_WIDE =
-        new Dop(DalvOps.SGET_WIDE, DalvOps.SGET_WIDE,
-            DalvOps.SGET_WIDE_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.SGET_WIDE, Opcodes.SGET_WIDE,
+            Opcodes.SGET_WIDE_JUMBO, Form21c.THE_ONE, true,
             "sget-wide");
 
     public static final Dop SGET_OBJECT =
-        new Dop(DalvOps.SGET_OBJECT, DalvOps.SGET_OBJECT,
-            DalvOps.SGET_OBJECT_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.SGET_OBJECT, Opcodes.SGET_OBJECT,
+            Opcodes.SGET_OBJECT_JUMBO, Form21c.THE_ONE, true,
             "sget-object");
 
     public static final Dop SGET_BOOLEAN =
-        new Dop(DalvOps.SGET_BOOLEAN, DalvOps.SGET_BOOLEAN,
-            DalvOps.SGET_BOOLEAN_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.SGET_BOOLEAN, Opcodes.SGET_BOOLEAN,
+            Opcodes.SGET_BOOLEAN_JUMBO, Form21c.THE_ONE, true,
             "sget-boolean");
 
     public static final Dop SGET_BYTE =
-        new Dop(DalvOps.SGET_BYTE, DalvOps.SGET_BYTE,
-            DalvOps.SGET_BYTE_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.SGET_BYTE, Opcodes.SGET_BYTE,
+            Opcodes.SGET_BYTE_JUMBO, Form21c.THE_ONE, true,
             "sget-byte");
 
     public static final Dop SGET_CHAR =
-        new Dop(DalvOps.SGET_CHAR, DalvOps.SGET_CHAR,
-            DalvOps.SGET_CHAR_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.SGET_CHAR, Opcodes.SGET_CHAR,
+            Opcodes.SGET_CHAR_JUMBO, Form21c.THE_ONE, true,
             "sget-char");
 
     public static final Dop SGET_SHORT =
-        new Dop(DalvOps.SGET_SHORT, DalvOps.SGET_SHORT,
-            DalvOps.SGET_SHORT_JUMBO, Form21c.THE_ONE, true,
+        new Dop(Opcodes.SGET_SHORT, Opcodes.SGET_SHORT,
+            Opcodes.SGET_SHORT_JUMBO, Form21c.THE_ONE, true,
             "sget-short");
 
     public static final Dop SPUT =
-        new Dop(DalvOps.SPUT, DalvOps.SPUT,
-            DalvOps.SPUT_JUMBO, Form21c.THE_ONE, false,
+        new Dop(Opcodes.SPUT, Opcodes.SPUT,
+            Opcodes.SPUT_JUMBO, Form21c.THE_ONE, false,
             "sput");
 
     public static final Dop SPUT_WIDE =
-        new Dop(DalvOps.SPUT_WIDE, DalvOps.SPUT_WIDE,
-            DalvOps.SPUT_WIDE_JUMBO, Form21c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_WIDE, Opcodes.SPUT_WIDE,
+            Opcodes.SPUT_WIDE_JUMBO, Form21c.THE_ONE, false,
             "sput-wide");
 
     public static final Dop SPUT_OBJECT =
-        new Dop(DalvOps.SPUT_OBJECT, DalvOps.SPUT_OBJECT,
-            DalvOps.SPUT_OBJECT_JUMBO, Form21c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_OBJECT, Opcodes.SPUT_OBJECT,
+            Opcodes.SPUT_OBJECT_JUMBO, Form21c.THE_ONE, false,
             "sput-object");
 
     public static final Dop SPUT_BOOLEAN =
-        new Dop(DalvOps.SPUT_BOOLEAN, DalvOps.SPUT_BOOLEAN,
-            DalvOps.SPUT_BOOLEAN_JUMBO, Form21c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_BOOLEAN, Opcodes.SPUT_BOOLEAN,
+            Opcodes.SPUT_BOOLEAN_JUMBO, Form21c.THE_ONE, false,
             "sput-boolean");
 
     public static final Dop SPUT_BYTE =
-        new Dop(DalvOps.SPUT_BYTE, DalvOps.SPUT_BYTE,
-            DalvOps.SPUT_BYTE_JUMBO, Form21c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_BYTE, Opcodes.SPUT_BYTE,
+            Opcodes.SPUT_BYTE_JUMBO, Form21c.THE_ONE, false,
             "sput-byte");
 
     public static final Dop SPUT_CHAR =
-        new Dop(DalvOps.SPUT_CHAR, DalvOps.SPUT_CHAR,
-            DalvOps.SPUT_CHAR_JUMBO, Form21c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_CHAR, Opcodes.SPUT_CHAR,
+            Opcodes.SPUT_CHAR_JUMBO, Form21c.THE_ONE, false,
             "sput-char");
 
     public static final Dop SPUT_SHORT =
-        new Dop(DalvOps.SPUT_SHORT, DalvOps.SPUT_SHORT,
-            DalvOps.SPUT_SHORT_JUMBO, Form21c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_SHORT, Opcodes.SPUT_SHORT,
+            Opcodes.SPUT_SHORT_JUMBO, Form21c.THE_ONE, false,
             "sput-short");
 
     public static final Dop INVOKE_VIRTUAL =
-        new Dop(DalvOps.INVOKE_VIRTUAL, DalvOps.INVOKE_VIRTUAL,
-            DalvOps.INVOKE_VIRTUAL_RANGE, Form35c.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_VIRTUAL, Opcodes.INVOKE_VIRTUAL,
+            Opcodes.INVOKE_VIRTUAL_RANGE, Form35c.THE_ONE, false,
             "invoke-virtual");
 
     public static final Dop INVOKE_SUPER =
-        new Dop(DalvOps.INVOKE_SUPER, DalvOps.INVOKE_SUPER,
-            DalvOps.INVOKE_SUPER_RANGE, Form35c.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_SUPER, Opcodes.INVOKE_SUPER,
+            Opcodes.INVOKE_SUPER_RANGE, Form35c.THE_ONE, false,
             "invoke-super");
 
     public static final Dop INVOKE_DIRECT =
-        new Dop(DalvOps.INVOKE_DIRECT, DalvOps.INVOKE_DIRECT,
-            DalvOps.INVOKE_DIRECT_RANGE, Form35c.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_DIRECT, Opcodes.INVOKE_DIRECT,
+            Opcodes.INVOKE_DIRECT_RANGE, Form35c.THE_ONE, false,
             "invoke-direct");
 
     public static final Dop INVOKE_STATIC =
-        new Dop(DalvOps.INVOKE_STATIC, DalvOps.INVOKE_STATIC,
-            DalvOps.INVOKE_STATIC_RANGE, Form35c.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_STATIC, Opcodes.INVOKE_STATIC,
+            Opcodes.INVOKE_STATIC_RANGE, Form35c.THE_ONE, false,
             "invoke-static");
 
     public static final Dop INVOKE_INTERFACE =
-        new Dop(DalvOps.INVOKE_INTERFACE, DalvOps.INVOKE_INTERFACE,
-            DalvOps.INVOKE_INTERFACE_RANGE, Form35c.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_INTERFACE, Opcodes.INVOKE_INTERFACE,
+            Opcodes.INVOKE_INTERFACE_RANGE, Form35c.THE_ONE, false,
             "invoke-interface");
 
     public static final Dop INVOKE_VIRTUAL_RANGE =
-        new Dop(DalvOps.INVOKE_VIRTUAL_RANGE, DalvOps.INVOKE_VIRTUAL,
-            DalvOps.INVOKE_VIRTUAL_JUMBO, Form3rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_VIRTUAL_RANGE, Opcodes.INVOKE_VIRTUAL,
+            Opcodes.INVOKE_VIRTUAL_JUMBO, Form3rc.THE_ONE, false,
             "invoke-virtual/range");
 
     public static final Dop INVOKE_SUPER_RANGE =
-        new Dop(DalvOps.INVOKE_SUPER_RANGE, DalvOps.INVOKE_SUPER,
-            DalvOps.INVOKE_SUPER_JUMBO, Form3rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_SUPER_RANGE, Opcodes.INVOKE_SUPER,
+            Opcodes.INVOKE_SUPER_JUMBO, Form3rc.THE_ONE, false,
             "invoke-super/range");
 
     public static final Dop INVOKE_DIRECT_RANGE =
-        new Dop(DalvOps.INVOKE_DIRECT_RANGE, DalvOps.INVOKE_DIRECT,
-            DalvOps.INVOKE_DIRECT_JUMBO, Form3rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_DIRECT_RANGE, Opcodes.INVOKE_DIRECT,
+            Opcodes.INVOKE_DIRECT_JUMBO, Form3rc.THE_ONE, false,
             "invoke-direct/range");
 
     public static final Dop INVOKE_STATIC_RANGE =
-        new Dop(DalvOps.INVOKE_STATIC_RANGE, DalvOps.INVOKE_STATIC,
-            DalvOps.INVOKE_STATIC_JUMBO, Form3rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_STATIC_RANGE, Opcodes.INVOKE_STATIC,
+            Opcodes.INVOKE_STATIC_JUMBO, Form3rc.THE_ONE, false,
             "invoke-static/range");
 
     public static final Dop INVOKE_INTERFACE_RANGE =
-        new Dop(DalvOps.INVOKE_INTERFACE_RANGE, DalvOps.INVOKE_INTERFACE,
-            DalvOps.INVOKE_INTERFACE_JUMBO, Form3rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_INTERFACE_RANGE, Opcodes.INVOKE_INTERFACE,
+            Opcodes.INVOKE_INTERFACE_JUMBO, Form3rc.THE_ONE, false,
             "invoke-interface/range");
 
     public static final Dop NEG_INT =
-        new Dop(DalvOps.NEG_INT, DalvOps.NEG_INT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.NEG_INT, Opcodes.NEG_INT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "neg-int");
 
     public static final Dop NOT_INT =
-        new Dop(DalvOps.NOT_INT, DalvOps.NOT_INT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.NOT_INT, Opcodes.NOT_INT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "not-int");
 
     public static final Dop NEG_LONG =
-        new Dop(DalvOps.NEG_LONG, DalvOps.NEG_LONG,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.NEG_LONG, Opcodes.NEG_LONG,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "neg-long");
 
     public static final Dop NOT_LONG =
-        new Dop(DalvOps.NOT_LONG, DalvOps.NOT_LONG,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.NOT_LONG, Opcodes.NOT_LONG,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "not-long");
 
     public static final Dop NEG_FLOAT =
-        new Dop(DalvOps.NEG_FLOAT, DalvOps.NEG_FLOAT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.NEG_FLOAT, Opcodes.NEG_FLOAT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "neg-float");
 
     public static final Dop NEG_DOUBLE =
-        new Dop(DalvOps.NEG_DOUBLE, DalvOps.NEG_DOUBLE,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.NEG_DOUBLE, Opcodes.NEG_DOUBLE,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "neg-double");
 
     public static final Dop INT_TO_LONG =
-        new Dop(DalvOps.INT_TO_LONG, DalvOps.INT_TO_LONG,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.INT_TO_LONG, Opcodes.INT_TO_LONG,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "int-to-long");
 
     public static final Dop INT_TO_FLOAT =
-        new Dop(DalvOps.INT_TO_FLOAT, DalvOps.INT_TO_FLOAT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.INT_TO_FLOAT, Opcodes.INT_TO_FLOAT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "int-to-float");
 
     public static final Dop INT_TO_DOUBLE =
-        new Dop(DalvOps.INT_TO_DOUBLE, DalvOps.INT_TO_DOUBLE,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.INT_TO_DOUBLE, Opcodes.INT_TO_DOUBLE,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "int-to-double");
 
     public static final Dop LONG_TO_INT =
-        new Dop(DalvOps.LONG_TO_INT, DalvOps.LONG_TO_INT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.LONG_TO_INT, Opcodes.LONG_TO_INT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "long-to-int");
 
     public static final Dop LONG_TO_FLOAT =
-        new Dop(DalvOps.LONG_TO_FLOAT, DalvOps.LONG_TO_FLOAT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.LONG_TO_FLOAT, Opcodes.LONG_TO_FLOAT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "long-to-float");
 
     public static final Dop LONG_TO_DOUBLE =
-        new Dop(DalvOps.LONG_TO_DOUBLE, DalvOps.LONG_TO_DOUBLE,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.LONG_TO_DOUBLE, Opcodes.LONG_TO_DOUBLE,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "long-to-double");
 
     public static final Dop FLOAT_TO_INT =
-        new Dop(DalvOps.FLOAT_TO_INT, DalvOps.FLOAT_TO_INT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.FLOAT_TO_INT, Opcodes.FLOAT_TO_INT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "float-to-int");
 
     public static final Dop FLOAT_TO_LONG =
-        new Dop(DalvOps.FLOAT_TO_LONG, DalvOps.FLOAT_TO_LONG,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.FLOAT_TO_LONG, Opcodes.FLOAT_TO_LONG,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "float-to-long");
 
     public static final Dop FLOAT_TO_DOUBLE =
-        new Dop(DalvOps.FLOAT_TO_DOUBLE, DalvOps.FLOAT_TO_DOUBLE,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.FLOAT_TO_DOUBLE, Opcodes.FLOAT_TO_DOUBLE,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "float-to-double");
 
     public static final Dop DOUBLE_TO_INT =
-        new Dop(DalvOps.DOUBLE_TO_INT, DalvOps.DOUBLE_TO_INT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.DOUBLE_TO_INT, Opcodes.DOUBLE_TO_INT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "double-to-int");
 
     public static final Dop DOUBLE_TO_LONG =
-        new Dop(DalvOps.DOUBLE_TO_LONG, DalvOps.DOUBLE_TO_LONG,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.DOUBLE_TO_LONG, Opcodes.DOUBLE_TO_LONG,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "double-to-long");
 
     public static final Dop DOUBLE_TO_FLOAT =
-        new Dop(DalvOps.DOUBLE_TO_FLOAT, DalvOps.DOUBLE_TO_FLOAT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.DOUBLE_TO_FLOAT, Opcodes.DOUBLE_TO_FLOAT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "double-to-float");
 
     public static final Dop INT_TO_BYTE =
-        new Dop(DalvOps.INT_TO_BYTE, DalvOps.INT_TO_BYTE,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.INT_TO_BYTE, Opcodes.INT_TO_BYTE,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "int-to-byte");
 
     public static final Dop INT_TO_CHAR =
-        new Dop(DalvOps.INT_TO_CHAR, DalvOps.INT_TO_CHAR,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.INT_TO_CHAR, Opcodes.INT_TO_CHAR,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "int-to-char");
 
     public static final Dop INT_TO_SHORT =
-        new Dop(DalvOps.INT_TO_SHORT, DalvOps.INT_TO_SHORT,
-            DalvOps.NO_NEXT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.INT_TO_SHORT, Opcodes.INT_TO_SHORT,
+            Opcodes.NO_NEXT, Form12x.THE_ONE, true,
             "int-to-short");
 
     public static final Dop ADD_INT =
-        new Dop(DalvOps.ADD_INT, DalvOps.ADD_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.ADD_INT, Opcodes.ADD_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "add-int");
 
     public static final Dop SUB_INT =
-        new Dop(DalvOps.SUB_INT, DalvOps.SUB_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.SUB_INT, Opcodes.SUB_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "sub-int");
 
     public static final Dop MUL_INT =
-        new Dop(DalvOps.MUL_INT, DalvOps.MUL_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.MUL_INT, Opcodes.MUL_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "mul-int");
 
     public static final Dop DIV_INT =
-        new Dop(DalvOps.DIV_INT, DalvOps.DIV_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.DIV_INT, Opcodes.DIV_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "div-int");
 
     public static final Dop REM_INT =
-        new Dop(DalvOps.REM_INT, DalvOps.REM_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.REM_INT, Opcodes.REM_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "rem-int");
 
     public static final Dop AND_INT =
-        new Dop(DalvOps.AND_INT, DalvOps.AND_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AND_INT, Opcodes.AND_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "and-int");
 
     public static final Dop OR_INT =
-        new Dop(DalvOps.OR_INT, DalvOps.OR_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.OR_INT, Opcodes.OR_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "or-int");
 
     public static final Dop XOR_INT =
-        new Dop(DalvOps.XOR_INT, DalvOps.XOR_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.XOR_INT, Opcodes.XOR_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "xor-int");
 
     public static final Dop SHL_INT =
-        new Dop(DalvOps.SHL_INT, DalvOps.SHL_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.SHL_INT, Opcodes.SHL_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "shl-int");
 
     public static final Dop SHR_INT =
-        new Dop(DalvOps.SHR_INT, DalvOps.SHR_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.SHR_INT, Opcodes.SHR_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "shr-int");
 
     public static final Dop USHR_INT =
-        new Dop(DalvOps.USHR_INT, DalvOps.USHR_INT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.USHR_INT, Opcodes.USHR_INT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "ushr-int");
 
     public static final Dop ADD_LONG =
-        new Dop(DalvOps.ADD_LONG, DalvOps.ADD_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.ADD_LONG, Opcodes.ADD_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "add-long");
 
     public static final Dop SUB_LONG =
-        new Dop(DalvOps.SUB_LONG, DalvOps.SUB_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.SUB_LONG, Opcodes.SUB_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "sub-long");
 
     public static final Dop MUL_LONG =
-        new Dop(DalvOps.MUL_LONG, DalvOps.MUL_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.MUL_LONG, Opcodes.MUL_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "mul-long");
 
     public static final Dop DIV_LONG =
-        new Dop(DalvOps.DIV_LONG, DalvOps.DIV_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.DIV_LONG, Opcodes.DIV_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "div-long");
 
     public static final Dop REM_LONG =
-        new Dop(DalvOps.REM_LONG, DalvOps.REM_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.REM_LONG, Opcodes.REM_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "rem-long");
 
     public static final Dop AND_LONG =
-        new Dop(DalvOps.AND_LONG, DalvOps.AND_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.AND_LONG, Opcodes.AND_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "and-long");
 
     public static final Dop OR_LONG =
-        new Dop(DalvOps.OR_LONG, DalvOps.OR_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.OR_LONG, Opcodes.OR_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "or-long");
 
     public static final Dop XOR_LONG =
-        new Dop(DalvOps.XOR_LONG, DalvOps.XOR_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.XOR_LONG, Opcodes.XOR_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "xor-long");
 
     public static final Dop SHL_LONG =
-        new Dop(DalvOps.SHL_LONG, DalvOps.SHL_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.SHL_LONG, Opcodes.SHL_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "shl-long");
 
     public static final Dop SHR_LONG =
-        new Dop(DalvOps.SHR_LONG, DalvOps.SHR_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.SHR_LONG, Opcodes.SHR_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "shr-long");
 
     public static final Dop USHR_LONG =
-        new Dop(DalvOps.USHR_LONG, DalvOps.USHR_LONG,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.USHR_LONG, Opcodes.USHR_LONG,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "ushr-long");
 
     public static final Dop ADD_FLOAT =
-        new Dop(DalvOps.ADD_FLOAT, DalvOps.ADD_FLOAT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.ADD_FLOAT, Opcodes.ADD_FLOAT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "add-float");
 
     public static final Dop SUB_FLOAT =
-        new Dop(DalvOps.SUB_FLOAT, DalvOps.SUB_FLOAT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.SUB_FLOAT, Opcodes.SUB_FLOAT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "sub-float");
 
     public static final Dop MUL_FLOAT =
-        new Dop(DalvOps.MUL_FLOAT, DalvOps.MUL_FLOAT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.MUL_FLOAT, Opcodes.MUL_FLOAT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "mul-float");
 
     public static final Dop DIV_FLOAT =
-        new Dop(DalvOps.DIV_FLOAT, DalvOps.DIV_FLOAT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.DIV_FLOAT, Opcodes.DIV_FLOAT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "div-float");
 
     public static final Dop REM_FLOAT =
-        new Dop(DalvOps.REM_FLOAT, DalvOps.REM_FLOAT,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.REM_FLOAT, Opcodes.REM_FLOAT,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "rem-float");
 
     public static final Dop ADD_DOUBLE =
-        new Dop(DalvOps.ADD_DOUBLE, DalvOps.ADD_DOUBLE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.ADD_DOUBLE, Opcodes.ADD_DOUBLE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "add-double");
 
     public static final Dop SUB_DOUBLE =
-        new Dop(DalvOps.SUB_DOUBLE, DalvOps.SUB_DOUBLE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.SUB_DOUBLE, Opcodes.SUB_DOUBLE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "sub-double");
 
     public static final Dop MUL_DOUBLE =
-        new Dop(DalvOps.MUL_DOUBLE, DalvOps.MUL_DOUBLE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.MUL_DOUBLE, Opcodes.MUL_DOUBLE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "mul-double");
 
     public static final Dop DIV_DOUBLE =
-        new Dop(DalvOps.DIV_DOUBLE, DalvOps.DIV_DOUBLE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.DIV_DOUBLE, Opcodes.DIV_DOUBLE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "div-double");
 
     public static final Dop REM_DOUBLE =
-        new Dop(DalvOps.REM_DOUBLE, DalvOps.REM_DOUBLE,
-            DalvOps.NO_NEXT, Form23x.THE_ONE, true,
+        new Dop(Opcodes.REM_DOUBLE, Opcodes.REM_DOUBLE,
+            Opcodes.NO_NEXT, Form23x.THE_ONE, true,
             "rem-double");
 
     public static final Dop ADD_INT_2ADDR =
-        new Dop(DalvOps.ADD_INT_2ADDR, DalvOps.ADD_INT,
-            DalvOps.ADD_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.ADD_INT_2ADDR, Opcodes.ADD_INT,
+            Opcodes.ADD_INT, Form12x.THE_ONE, true,
             "add-int/2addr");
 
     public static final Dop SUB_INT_2ADDR =
-        new Dop(DalvOps.SUB_INT_2ADDR, DalvOps.SUB_INT,
-            DalvOps.SUB_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.SUB_INT_2ADDR, Opcodes.SUB_INT,
+            Opcodes.SUB_INT, Form12x.THE_ONE, true,
             "sub-int/2addr");
 
     public static final Dop MUL_INT_2ADDR =
-        new Dop(DalvOps.MUL_INT_2ADDR, DalvOps.MUL_INT,
-            DalvOps.MUL_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.MUL_INT_2ADDR, Opcodes.MUL_INT,
+            Opcodes.MUL_INT, Form12x.THE_ONE, true,
             "mul-int/2addr");
 
     public static final Dop DIV_INT_2ADDR =
-        new Dop(DalvOps.DIV_INT_2ADDR, DalvOps.DIV_INT,
-            DalvOps.DIV_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.DIV_INT_2ADDR, Opcodes.DIV_INT,
+            Opcodes.DIV_INT, Form12x.THE_ONE, true,
             "div-int/2addr");
 
     public static final Dop REM_INT_2ADDR =
-        new Dop(DalvOps.REM_INT_2ADDR, DalvOps.REM_INT,
-            DalvOps.REM_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.REM_INT_2ADDR, Opcodes.REM_INT,
+            Opcodes.REM_INT, Form12x.THE_ONE, true,
             "rem-int/2addr");
 
     public static final Dop AND_INT_2ADDR =
-        new Dop(DalvOps.AND_INT_2ADDR, DalvOps.AND_INT,
-            DalvOps.AND_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.AND_INT_2ADDR, Opcodes.AND_INT,
+            Opcodes.AND_INT, Form12x.THE_ONE, true,
             "and-int/2addr");
 
     public static final Dop OR_INT_2ADDR =
-        new Dop(DalvOps.OR_INT_2ADDR, DalvOps.OR_INT,
-            DalvOps.OR_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.OR_INT_2ADDR, Opcodes.OR_INT,
+            Opcodes.OR_INT, Form12x.THE_ONE, true,
             "or-int/2addr");
 
     public static final Dop XOR_INT_2ADDR =
-        new Dop(DalvOps.XOR_INT_2ADDR, DalvOps.XOR_INT,
-            DalvOps.XOR_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.XOR_INT_2ADDR, Opcodes.XOR_INT,
+            Opcodes.XOR_INT, Form12x.THE_ONE, true,
             "xor-int/2addr");
 
     public static final Dop SHL_INT_2ADDR =
-        new Dop(DalvOps.SHL_INT_2ADDR, DalvOps.SHL_INT,
-            DalvOps.SHL_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.SHL_INT_2ADDR, Opcodes.SHL_INT,
+            Opcodes.SHL_INT, Form12x.THE_ONE, true,
             "shl-int/2addr");
 
     public static final Dop SHR_INT_2ADDR =
-        new Dop(DalvOps.SHR_INT_2ADDR, DalvOps.SHR_INT,
-            DalvOps.SHR_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.SHR_INT_2ADDR, Opcodes.SHR_INT,
+            Opcodes.SHR_INT, Form12x.THE_ONE, true,
             "shr-int/2addr");
 
     public static final Dop USHR_INT_2ADDR =
-        new Dop(DalvOps.USHR_INT_2ADDR, DalvOps.USHR_INT,
-            DalvOps.USHR_INT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.USHR_INT_2ADDR, Opcodes.USHR_INT,
+            Opcodes.USHR_INT, Form12x.THE_ONE, true,
             "ushr-int/2addr");
 
     public static final Dop ADD_LONG_2ADDR =
-        new Dop(DalvOps.ADD_LONG_2ADDR, DalvOps.ADD_LONG,
-            DalvOps.ADD_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.ADD_LONG_2ADDR, Opcodes.ADD_LONG,
+            Opcodes.ADD_LONG, Form12x.THE_ONE, true,
             "add-long/2addr");
 
     public static final Dop SUB_LONG_2ADDR =
-        new Dop(DalvOps.SUB_LONG_2ADDR, DalvOps.SUB_LONG,
-            DalvOps.SUB_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.SUB_LONG_2ADDR, Opcodes.SUB_LONG,
+            Opcodes.SUB_LONG, Form12x.THE_ONE, true,
             "sub-long/2addr");
 
     public static final Dop MUL_LONG_2ADDR =
-        new Dop(DalvOps.MUL_LONG_2ADDR, DalvOps.MUL_LONG,
-            DalvOps.MUL_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.MUL_LONG_2ADDR, Opcodes.MUL_LONG,
+            Opcodes.MUL_LONG, Form12x.THE_ONE, true,
             "mul-long/2addr");
 
     public static final Dop DIV_LONG_2ADDR =
-        new Dop(DalvOps.DIV_LONG_2ADDR, DalvOps.DIV_LONG,
-            DalvOps.DIV_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.DIV_LONG_2ADDR, Opcodes.DIV_LONG,
+            Opcodes.DIV_LONG, Form12x.THE_ONE, true,
             "div-long/2addr");
 
     public static final Dop REM_LONG_2ADDR =
-        new Dop(DalvOps.REM_LONG_2ADDR, DalvOps.REM_LONG,
-            DalvOps.REM_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.REM_LONG_2ADDR, Opcodes.REM_LONG,
+            Opcodes.REM_LONG, Form12x.THE_ONE, true,
             "rem-long/2addr");
 
     public static final Dop AND_LONG_2ADDR =
-        new Dop(DalvOps.AND_LONG_2ADDR, DalvOps.AND_LONG,
-            DalvOps.AND_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.AND_LONG_2ADDR, Opcodes.AND_LONG,
+            Opcodes.AND_LONG, Form12x.THE_ONE, true,
             "and-long/2addr");
 
     public static final Dop OR_LONG_2ADDR =
-        new Dop(DalvOps.OR_LONG_2ADDR, DalvOps.OR_LONG,
-            DalvOps.OR_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.OR_LONG_2ADDR, Opcodes.OR_LONG,
+            Opcodes.OR_LONG, Form12x.THE_ONE, true,
             "or-long/2addr");
 
     public static final Dop XOR_LONG_2ADDR =
-        new Dop(DalvOps.XOR_LONG_2ADDR, DalvOps.XOR_LONG,
-            DalvOps.XOR_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.XOR_LONG_2ADDR, Opcodes.XOR_LONG,
+            Opcodes.XOR_LONG, Form12x.THE_ONE, true,
             "xor-long/2addr");
 
     public static final Dop SHL_LONG_2ADDR =
-        new Dop(DalvOps.SHL_LONG_2ADDR, DalvOps.SHL_LONG,
-            DalvOps.SHL_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.SHL_LONG_2ADDR, Opcodes.SHL_LONG,
+            Opcodes.SHL_LONG, Form12x.THE_ONE, true,
             "shl-long/2addr");
 
     public static final Dop SHR_LONG_2ADDR =
-        new Dop(DalvOps.SHR_LONG_2ADDR, DalvOps.SHR_LONG,
-            DalvOps.SHR_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.SHR_LONG_2ADDR, Opcodes.SHR_LONG,
+            Opcodes.SHR_LONG, Form12x.THE_ONE, true,
             "shr-long/2addr");
 
     public static final Dop USHR_LONG_2ADDR =
-        new Dop(DalvOps.USHR_LONG_2ADDR, DalvOps.USHR_LONG,
-            DalvOps.USHR_LONG, Form12x.THE_ONE, true,
+        new Dop(Opcodes.USHR_LONG_2ADDR, Opcodes.USHR_LONG,
+            Opcodes.USHR_LONG, Form12x.THE_ONE, true,
             "ushr-long/2addr");
 
     public static final Dop ADD_FLOAT_2ADDR =
-        new Dop(DalvOps.ADD_FLOAT_2ADDR, DalvOps.ADD_FLOAT,
-            DalvOps.ADD_FLOAT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.ADD_FLOAT_2ADDR, Opcodes.ADD_FLOAT,
+            Opcodes.ADD_FLOAT, Form12x.THE_ONE, true,
             "add-float/2addr");
 
     public static final Dop SUB_FLOAT_2ADDR =
-        new Dop(DalvOps.SUB_FLOAT_2ADDR, DalvOps.SUB_FLOAT,
-            DalvOps.SUB_FLOAT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.SUB_FLOAT_2ADDR, Opcodes.SUB_FLOAT,
+            Opcodes.SUB_FLOAT, Form12x.THE_ONE, true,
             "sub-float/2addr");
 
     public static final Dop MUL_FLOAT_2ADDR =
-        new Dop(DalvOps.MUL_FLOAT_2ADDR, DalvOps.MUL_FLOAT,
-            DalvOps.MUL_FLOAT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.MUL_FLOAT_2ADDR, Opcodes.MUL_FLOAT,
+            Opcodes.MUL_FLOAT, Form12x.THE_ONE, true,
             "mul-float/2addr");
 
     public static final Dop DIV_FLOAT_2ADDR =
-        new Dop(DalvOps.DIV_FLOAT_2ADDR, DalvOps.DIV_FLOAT,
-            DalvOps.DIV_FLOAT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.DIV_FLOAT_2ADDR, Opcodes.DIV_FLOAT,
+            Opcodes.DIV_FLOAT, Form12x.THE_ONE, true,
             "div-float/2addr");
 
     public static final Dop REM_FLOAT_2ADDR =
-        new Dop(DalvOps.REM_FLOAT_2ADDR, DalvOps.REM_FLOAT,
-            DalvOps.REM_FLOAT, Form12x.THE_ONE, true,
+        new Dop(Opcodes.REM_FLOAT_2ADDR, Opcodes.REM_FLOAT,
+            Opcodes.REM_FLOAT, Form12x.THE_ONE, true,
             "rem-float/2addr");
 
     public static final Dop ADD_DOUBLE_2ADDR =
-        new Dop(DalvOps.ADD_DOUBLE_2ADDR, DalvOps.ADD_DOUBLE,
-            DalvOps.ADD_DOUBLE, Form12x.THE_ONE, true,
+        new Dop(Opcodes.ADD_DOUBLE_2ADDR, Opcodes.ADD_DOUBLE,
+            Opcodes.ADD_DOUBLE, Form12x.THE_ONE, true,
             "add-double/2addr");
 
     public static final Dop SUB_DOUBLE_2ADDR =
-        new Dop(DalvOps.SUB_DOUBLE_2ADDR, DalvOps.SUB_DOUBLE,
-            DalvOps.SUB_DOUBLE, Form12x.THE_ONE, true,
+        new Dop(Opcodes.SUB_DOUBLE_2ADDR, Opcodes.SUB_DOUBLE,
+            Opcodes.SUB_DOUBLE, Form12x.THE_ONE, true,
             "sub-double/2addr");
 
     public static final Dop MUL_DOUBLE_2ADDR =
-        new Dop(DalvOps.MUL_DOUBLE_2ADDR, DalvOps.MUL_DOUBLE,
-            DalvOps.MUL_DOUBLE, Form12x.THE_ONE, true,
+        new Dop(Opcodes.MUL_DOUBLE_2ADDR, Opcodes.MUL_DOUBLE,
+            Opcodes.MUL_DOUBLE, Form12x.THE_ONE, true,
             "mul-double/2addr");
 
     public static final Dop DIV_DOUBLE_2ADDR =
-        new Dop(DalvOps.DIV_DOUBLE_2ADDR, DalvOps.DIV_DOUBLE,
-            DalvOps.DIV_DOUBLE, Form12x.THE_ONE, true,
+        new Dop(Opcodes.DIV_DOUBLE_2ADDR, Opcodes.DIV_DOUBLE,
+            Opcodes.DIV_DOUBLE, Form12x.THE_ONE, true,
             "div-double/2addr");
 
     public static final Dop REM_DOUBLE_2ADDR =
-        new Dop(DalvOps.REM_DOUBLE_2ADDR, DalvOps.REM_DOUBLE,
-            DalvOps.REM_DOUBLE, Form12x.THE_ONE, true,
+        new Dop(Opcodes.REM_DOUBLE_2ADDR, Opcodes.REM_DOUBLE,
+            Opcodes.REM_DOUBLE, Form12x.THE_ONE, true,
             "rem-double/2addr");
 
     public static final Dop ADD_INT_LIT16 =
-        new Dop(DalvOps.ADD_INT_LIT16, DalvOps.ADD_INT,
-            DalvOps.NO_NEXT, Form22s.THE_ONE, true,
+        new Dop(Opcodes.ADD_INT_LIT16, Opcodes.ADD_INT,
+            Opcodes.NO_NEXT, Form22s.THE_ONE, true,
             "add-int/lit16");
 
     public static final Dop RSUB_INT =
-        new Dop(DalvOps.RSUB_INT, DalvOps.RSUB_INT,
-            DalvOps.NO_NEXT, Form22s.THE_ONE, true,
+        new Dop(Opcodes.RSUB_INT, Opcodes.RSUB_INT,
+            Opcodes.NO_NEXT, Form22s.THE_ONE, true,
             "rsub-int");
 
     public static final Dop MUL_INT_LIT16 =
-        new Dop(DalvOps.MUL_INT_LIT16, DalvOps.MUL_INT,
-            DalvOps.NO_NEXT, Form22s.THE_ONE, true,
+        new Dop(Opcodes.MUL_INT_LIT16, Opcodes.MUL_INT,
+            Opcodes.NO_NEXT, Form22s.THE_ONE, true,
             "mul-int/lit16");
 
     public static final Dop DIV_INT_LIT16 =
-        new Dop(DalvOps.DIV_INT_LIT16, DalvOps.DIV_INT,
-            DalvOps.NO_NEXT, Form22s.THE_ONE, true,
+        new Dop(Opcodes.DIV_INT_LIT16, Opcodes.DIV_INT,
+            Opcodes.NO_NEXT, Form22s.THE_ONE, true,
             "div-int/lit16");
 
     public static final Dop REM_INT_LIT16 =
-        new Dop(DalvOps.REM_INT_LIT16, DalvOps.REM_INT,
-            DalvOps.NO_NEXT, Form22s.THE_ONE, true,
+        new Dop(Opcodes.REM_INT_LIT16, Opcodes.REM_INT,
+            Opcodes.NO_NEXT, Form22s.THE_ONE, true,
             "rem-int/lit16");
 
     public static final Dop AND_INT_LIT16 =
-        new Dop(DalvOps.AND_INT_LIT16, DalvOps.AND_INT,
-            DalvOps.NO_NEXT, Form22s.THE_ONE, true,
+        new Dop(Opcodes.AND_INT_LIT16, Opcodes.AND_INT,
+            Opcodes.NO_NEXT, Form22s.THE_ONE, true,
             "and-int/lit16");
 
     public static final Dop OR_INT_LIT16 =
-        new Dop(DalvOps.OR_INT_LIT16, DalvOps.OR_INT,
-            DalvOps.NO_NEXT, Form22s.THE_ONE, true,
+        new Dop(Opcodes.OR_INT_LIT16, Opcodes.OR_INT,
+            Opcodes.NO_NEXT, Form22s.THE_ONE, true,
             "or-int/lit16");
 
     public static final Dop XOR_INT_LIT16 =
-        new Dop(DalvOps.XOR_INT_LIT16, DalvOps.XOR_INT,
-            DalvOps.NO_NEXT, Form22s.THE_ONE, true,
+        new Dop(Opcodes.XOR_INT_LIT16, Opcodes.XOR_INT,
+            Opcodes.NO_NEXT, Form22s.THE_ONE, true,
             "xor-int/lit16");
 
     public static final Dop ADD_INT_LIT8 =
-        new Dop(DalvOps.ADD_INT_LIT8, DalvOps.ADD_INT,
-            DalvOps.ADD_INT_LIT16, Form22b.THE_ONE, true,
+        new Dop(Opcodes.ADD_INT_LIT8, Opcodes.ADD_INT,
+            Opcodes.ADD_INT_LIT16, Form22b.THE_ONE, true,
             "add-int/lit8");
 
     public static final Dop RSUB_INT_LIT8 =
-        new Dop(DalvOps.RSUB_INT_LIT8, DalvOps.RSUB_INT,
-            DalvOps.RSUB_INT, Form22b.THE_ONE, true,
+        new Dop(Opcodes.RSUB_INT_LIT8, Opcodes.RSUB_INT,
+            Opcodes.RSUB_INT, Form22b.THE_ONE, true,
             "rsub-int/lit8");
 
     public static final Dop MUL_INT_LIT8 =
-        new Dop(DalvOps.MUL_INT_LIT8, DalvOps.MUL_INT,
-            DalvOps.MUL_INT_LIT16, Form22b.THE_ONE, true,
+        new Dop(Opcodes.MUL_INT_LIT8, Opcodes.MUL_INT,
+            Opcodes.MUL_INT_LIT16, Form22b.THE_ONE, true,
             "mul-int/lit8");
 
     public static final Dop DIV_INT_LIT8 =
-        new Dop(DalvOps.DIV_INT_LIT8, DalvOps.DIV_INT,
-            DalvOps.DIV_INT_LIT16, Form22b.THE_ONE, true,
+        new Dop(Opcodes.DIV_INT_LIT8, Opcodes.DIV_INT,
+            Opcodes.DIV_INT_LIT16, Form22b.THE_ONE, true,
             "div-int/lit8");
 
     public static final Dop REM_INT_LIT8 =
-        new Dop(DalvOps.REM_INT_LIT8, DalvOps.REM_INT,
-            DalvOps.REM_INT_LIT16, Form22b.THE_ONE, true,
+        new Dop(Opcodes.REM_INT_LIT8, Opcodes.REM_INT,
+            Opcodes.REM_INT_LIT16, Form22b.THE_ONE, true,
             "rem-int/lit8");
 
     public static final Dop AND_INT_LIT8 =
-        new Dop(DalvOps.AND_INT_LIT8, DalvOps.AND_INT,
-            DalvOps.AND_INT_LIT16, Form22b.THE_ONE, true,
+        new Dop(Opcodes.AND_INT_LIT8, Opcodes.AND_INT,
+            Opcodes.AND_INT_LIT16, Form22b.THE_ONE, true,
             "and-int/lit8");
 
     public static final Dop OR_INT_LIT8 =
-        new Dop(DalvOps.OR_INT_LIT8, DalvOps.OR_INT,
-            DalvOps.OR_INT_LIT16, Form22b.THE_ONE, true,
+        new Dop(Opcodes.OR_INT_LIT8, Opcodes.OR_INT,
+            Opcodes.OR_INT_LIT16, Form22b.THE_ONE, true,
             "or-int/lit8");
 
     public static final Dop XOR_INT_LIT8 =
-        new Dop(DalvOps.XOR_INT_LIT8, DalvOps.XOR_INT,
-            DalvOps.XOR_INT_LIT16, Form22b.THE_ONE, true,
+        new Dop(Opcodes.XOR_INT_LIT8, Opcodes.XOR_INT,
+            Opcodes.XOR_INT_LIT16, Form22b.THE_ONE, true,
             "xor-int/lit8");
 
     public static final Dop SHL_INT_LIT8 =
-        new Dop(DalvOps.SHL_INT_LIT8, DalvOps.SHL_INT,
-            DalvOps.NO_NEXT, Form22b.THE_ONE, true,
+        new Dop(Opcodes.SHL_INT_LIT8, Opcodes.SHL_INT,
+            Opcodes.NO_NEXT, Form22b.THE_ONE, true,
             "shl-int/lit8");
 
     public static final Dop SHR_INT_LIT8 =
-        new Dop(DalvOps.SHR_INT_LIT8, DalvOps.SHR_INT,
-            DalvOps.NO_NEXT, Form22b.THE_ONE, true,
+        new Dop(Opcodes.SHR_INT_LIT8, Opcodes.SHR_INT,
+            Opcodes.NO_NEXT, Form22b.THE_ONE, true,
             "shr-int/lit8");
 
     public static final Dop USHR_INT_LIT8 =
-        new Dop(DalvOps.USHR_INT_LIT8, DalvOps.USHR_INT,
-            DalvOps.NO_NEXT, Form22b.THE_ONE, true,
+        new Dop(Opcodes.USHR_INT_LIT8, Opcodes.USHR_INT,
+            Opcodes.NO_NEXT, Form22b.THE_ONE, true,
             "ushr-int/lit8");
 
     public static final Dop CONST_CLASS_JUMBO =
-        new Dop(DalvOps.CONST_CLASS_JUMBO, DalvOps.CONST_CLASS,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.CONST_CLASS_JUMBO, Opcodes.CONST_CLASS,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "const-class/jumbo");
 
     public static final Dop CHECK_CAST_JUMBO =
-        new Dop(DalvOps.CHECK_CAST_JUMBO, DalvOps.CHECK_CAST,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, false,
+        new Dop(Opcodes.CHECK_CAST_JUMBO, Opcodes.CHECK_CAST,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, false,
             "check-cast/jumbo");
 
     public static final Dop INSTANCE_OF_JUMBO =
-        new Dop(DalvOps.INSTANCE_OF_JUMBO, DalvOps.INSTANCE_OF,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.INSTANCE_OF_JUMBO, Opcodes.INSTANCE_OF,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "instance-of/jumbo");
 
     public static final Dop NEW_INSTANCE_JUMBO =
-        new Dop(DalvOps.NEW_INSTANCE_JUMBO, DalvOps.NEW_INSTANCE,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.NEW_INSTANCE_JUMBO, Opcodes.NEW_INSTANCE,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "new-instance/jumbo");
 
     public static final Dop NEW_ARRAY_JUMBO =
-        new Dop(DalvOps.NEW_ARRAY_JUMBO, DalvOps.NEW_ARRAY,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.NEW_ARRAY_JUMBO, Opcodes.NEW_ARRAY,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "new-array/jumbo");
 
     public static final Dop FILLED_NEW_ARRAY_JUMBO =
-        new Dop(DalvOps.FILLED_NEW_ARRAY_JUMBO, DalvOps.FILLED_NEW_ARRAY,
-            DalvOps.NO_NEXT, Form5rc.THE_ONE, false,
+        new Dop(Opcodes.FILLED_NEW_ARRAY_JUMBO, Opcodes.FILLED_NEW_ARRAY,
+            Opcodes.NO_NEXT, Form5rc.THE_ONE, false,
             "filled-new-array/jumbo");
 
     public static final Dop IGET_JUMBO =
-        new Dop(DalvOps.IGET_JUMBO, DalvOps.IGET,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.IGET_JUMBO, Opcodes.IGET,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "iget/jumbo");
 
     public static final Dop IGET_WIDE_JUMBO =
-        new Dop(DalvOps.IGET_WIDE_JUMBO, DalvOps.IGET_WIDE,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.IGET_WIDE_JUMBO, Opcodes.IGET_WIDE,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "iget-wide/jumbo");
 
     public static final Dop IGET_OBJECT_JUMBO =
-        new Dop(DalvOps.IGET_OBJECT_JUMBO, DalvOps.IGET_OBJECT,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.IGET_OBJECT_JUMBO, Opcodes.IGET_OBJECT,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "iget-object/jumbo");
 
     public static final Dop IGET_BOOLEAN_JUMBO =
-        new Dop(DalvOps.IGET_BOOLEAN_JUMBO, DalvOps.IGET_BOOLEAN,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.IGET_BOOLEAN_JUMBO, Opcodes.IGET_BOOLEAN,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "iget-boolean/jumbo");
 
     public static final Dop IGET_BYTE_JUMBO =
-        new Dop(DalvOps.IGET_BYTE_JUMBO, DalvOps.IGET_BYTE,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.IGET_BYTE_JUMBO, Opcodes.IGET_BYTE,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "iget-byte/jumbo");
 
     public static final Dop IGET_CHAR_JUMBO =
-        new Dop(DalvOps.IGET_CHAR_JUMBO, DalvOps.IGET_CHAR,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.IGET_CHAR_JUMBO, Opcodes.IGET_CHAR,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "iget-char/jumbo");
 
     public static final Dop IGET_SHORT_JUMBO =
-        new Dop(DalvOps.IGET_SHORT_JUMBO, DalvOps.IGET_SHORT,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, true,
+        new Dop(Opcodes.IGET_SHORT_JUMBO, Opcodes.IGET_SHORT,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, true,
             "iget-short/jumbo");
 
     public static final Dop IPUT_JUMBO =
-        new Dop(DalvOps.IPUT_JUMBO, DalvOps.IPUT,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_JUMBO, Opcodes.IPUT,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, false,
             "iput/jumbo");
 
     public static final Dop IPUT_WIDE_JUMBO =
-        new Dop(DalvOps.IPUT_WIDE_JUMBO, DalvOps.IPUT_WIDE,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_WIDE_JUMBO, Opcodes.IPUT_WIDE,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, false,
             "iput-wide/jumbo");
 
     public static final Dop IPUT_OBJECT_JUMBO =
-        new Dop(DalvOps.IPUT_OBJECT_JUMBO, DalvOps.IPUT_OBJECT,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_OBJECT_JUMBO, Opcodes.IPUT_OBJECT,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, false,
             "iput-object/jumbo");
 
     public static final Dop IPUT_BOOLEAN_JUMBO =
-        new Dop(DalvOps.IPUT_BOOLEAN_JUMBO, DalvOps.IPUT_BOOLEAN,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_BOOLEAN_JUMBO, Opcodes.IPUT_BOOLEAN,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, false,
             "iput-boolean/jumbo");
 
     public static final Dop IPUT_BYTE_JUMBO =
-        new Dop(DalvOps.IPUT_BYTE_JUMBO, DalvOps.IPUT_BYTE,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_BYTE_JUMBO, Opcodes.IPUT_BYTE,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, false,
             "iput-byte/jumbo");
 
     public static final Dop IPUT_CHAR_JUMBO =
-        new Dop(DalvOps.IPUT_CHAR_JUMBO, DalvOps.IPUT_CHAR,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_CHAR_JUMBO, Opcodes.IPUT_CHAR,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, false,
             "iput-char/jumbo");
 
     public static final Dop IPUT_SHORT_JUMBO =
-        new Dop(DalvOps.IPUT_SHORT_JUMBO, DalvOps.IPUT_SHORT,
-            DalvOps.NO_NEXT, Form52c.THE_ONE, false,
+        new Dop(Opcodes.IPUT_SHORT_JUMBO, Opcodes.IPUT_SHORT,
+            Opcodes.NO_NEXT, Form52c.THE_ONE, false,
             "iput-short/jumbo");
 
     public static final Dop SGET_JUMBO =
-        new Dop(DalvOps.SGET_JUMBO, DalvOps.SGET,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.SGET_JUMBO, Opcodes.SGET,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "sget/jumbo");
 
     public static final Dop SGET_WIDE_JUMBO =
-        new Dop(DalvOps.SGET_WIDE_JUMBO, DalvOps.SGET_WIDE,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.SGET_WIDE_JUMBO, Opcodes.SGET_WIDE,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "sget-wide/jumbo");
 
     public static final Dop SGET_OBJECT_JUMBO =
-        new Dop(DalvOps.SGET_OBJECT_JUMBO, DalvOps.SGET_OBJECT,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.SGET_OBJECT_JUMBO, Opcodes.SGET_OBJECT,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "sget-object/jumbo");
 
     public static final Dop SGET_BOOLEAN_JUMBO =
-        new Dop(DalvOps.SGET_BOOLEAN_JUMBO, DalvOps.SGET_BOOLEAN,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.SGET_BOOLEAN_JUMBO, Opcodes.SGET_BOOLEAN,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "sget-boolean/jumbo");
 
     public static final Dop SGET_BYTE_JUMBO =
-        new Dop(DalvOps.SGET_BYTE_JUMBO, DalvOps.SGET_BYTE,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.SGET_BYTE_JUMBO, Opcodes.SGET_BYTE,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "sget-byte/jumbo");
 
     public static final Dop SGET_CHAR_JUMBO =
-        new Dop(DalvOps.SGET_CHAR_JUMBO, DalvOps.SGET_CHAR,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.SGET_CHAR_JUMBO, Opcodes.SGET_CHAR,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "sget-char/jumbo");
 
     public static final Dop SGET_SHORT_JUMBO =
-        new Dop(DalvOps.SGET_SHORT_JUMBO, DalvOps.SGET_SHORT,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, true,
+        new Dop(Opcodes.SGET_SHORT_JUMBO, Opcodes.SGET_SHORT,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, true,
             "sget-short/jumbo");
 
     public static final Dop SPUT_JUMBO =
-        new Dop(DalvOps.SPUT_JUMBO, DalvOps.SPUT,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_JUMBO, Opcodes.SPUT,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, false,
             "sput/jumbo");
 
     public static final Dop SPUT_WIDE_JUMBO =
-        new Dop(DalvOps.SPUT_WIDE_JUMBO, DalvOps.SPUT_WIDE,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_WIDE_JUMBO, Opcodes.SPUT_WIDE,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, false,
             "sput-wide/jumbo");
 
     public static final Dop SPUT_OBJECT_JUMBO =
-        new Dop(DalvOps.SPUT_OBJECT_JUMBO, DalvOps.SPUT_OBJECT,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_OBJECT_JUMBO, Opcodes.SPUT_OBJECT,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, false,
             "sput-object/jumbo");
 
     public static final Dop SPUT_BOOLEAN_JUMBO =
-        new Dop(DalvOps.SPUT_BOOLEAN_JUMBO, DalvOps.SPUT_BOOLEAN,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_BOOLEAN_JUMBO, Opcodes.SPUT_BOOLEAN,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, false,
             "sput-boolean/jumbo");
 
     public static final Dop SPUT_BYTE_JUMBO =
-        new Dop(DalvOps.SPUT_BYTE_JUMBO, DalvOps.SPUT_BYTE,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_BYTE_JUMBO, Opcodes.SPUT_BYTE,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, false,
             "sput-byte/jumbo");
 
     public static final Dop SPUT_CHAR_JUMBO =
-        new Dop(DalvOps.SPUT_CHAR_JUMBO, DalvOps.SPUT_CHAR,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_CHAR_JUMBO, Opcodes.SPUT_CHAR,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, false,
             "sput-char/jumbo");
 
     public static final Dop SPUT_SHORT_JUMBO =
-        new Dop(DalvOps.SPUT_SHORT_JUMBO, DalvOps.SPUT_SHORT,
-            DalvOps.NO_NEXT, Form41c.THE_ONE, false,
+        new Dop(Opcodes.SPUT_SHORT_JUMBO, Opcodes.SPUT_SHORT,
+            Opcodes.NO_NEXT, Form41c.THE_ONE, false,
             "sput-short/jumbo");
 
     public static final Dop INVOKE_VIRTUAL_JUMBO =
-        new Dop(DalvOps.INVOKE_VIRTUAL_JUMBO, DalvOps.INVOKE_VIRTUAL,
-            DalvOps.NO_NEXT, Form5rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_VIRTUAL_JUMBO, Opcodes.INVOKE_VIRTUAL,
+            Opcodes.NO_NEXT, Form5rc.THE_ONE, false,
             "invoke-virtual/jumbo");
 
     public static final Dop INVOKE_SUPER_JUMBO =
-        new Dop(DalvOps.INVOKE_SUPER_JUMBO, DalvOps.INVOKE_SUPER,
-            DalvOps.NO_NEXT, Form5rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_SUPER_JUMBO, Opcodes.INVOKE_SUPER,
+            Opcodes.NO_NEXT, Form5rc.THE_ONE, false,
             "invoke-super/jumbo");
 
     public static final Dop INVOKE_DIRECT_JUMBO =
-        new Dop(DalvOps.INVOKE_DIRECT_JUMBO, DalvOps.INVOKE_DIRECT,
-            DalvOps.NO_NEXT, Form5rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_DIRECT_JUMBO, Opcodes.INVOKE_DIRECT,
+            Opcodes.NO_NEXT, Form5rc.THE_ONE, false,
             "invoke-direct/jumbo");
 
     public static final Dop INVOKE_STATIC_JUMBO =
-        new Dop(DalvOps.INVOKE_STATIC_JUMBO, DalvOps.INVOKE_STATIC,
-            DalvOps.NO_NEXT, Form5rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_STATIC_JUMBO, Opcodes.INVOKE_STATIC,
+            Opcodes.NO_NEXT, Form5rc.THE_ONE, false,
             "invoke-static/jumbo");
 
     public static final Dop INVOKE_INTERFACE_JUMBO =
-        new Dop(DalvOps.INVOKE_INTERFACE_JUMBO, DalvOps.INVOKE_INTERFACE,
-            DalvOps.NO_NEXT, Form5rc.THE_ONE, false,
+        new Dop(Opcodes.INVOKE_INTERFACE_JUMBO, Opcodes.INVOKE_INTERFACE,
+            Opcodes.NO_NEXT, Form5rc.THE_ONE, false,
             "invoke-interface/jumbo");
 
     // END(dops)
 
     // Static initialization.
     static {
-        DOPS = new Dop[DalvOps.MAX_VALUE - DalvOps.MIN_VALUE + 1];
+        DOPS = new Dop[Opcodes.MAX_VALUE - Opcodes.MIN_VALUE + 1];
 
         set(SPECIAL_FORMAT);
 
@@ -1627,12 +1628,12 @@ public final class Dops {
     /**
      * Gets the {@link Dop} for the given opcode value.
      *
-     * @param opcode {@code DalvOps.MIN_VALUE..DalvOps.MAX_VALUE;} the
+     * @param opcode {@code Opcodes.MIN_VALUE..Opcodes.MAX_VALUE;} the
      * opcode value
      * @return {@code non-null;} the associated opcode instance
      */
     public static Dop get(int opcode) {
-        int idx = opcode - DalvOps.MIN_VALUE;
+        int idx = opcode - Opcodes.MIN_VALUE;
 
         try {
             Dop result = DOPS[idx];
@@ -1658,7 +1659,7 @@ public final class Dops {
     public static Dop getNextOrNull(Dop opcode) {
         int nextOpcode = opcode.getNextOpcode();
 
-        if (nextOpcode == DalvOps.NO_NEXT) {
+        if (nextOpcode == Opcodes.NO_NEXT) {
             return null;
         }
 
@@ -1671,7 +1672,7 @@ public final class Dops {
      * @param opcode {@code non-null;} the opcode
      */
     private static void set(Dop opcode) {
-        int idx = opcode.getOpcode() - DalvOps.MIN_VALUE;
+        int idx = opcode.getOpcode() - Opcodes.MIN_VALUE;
         DOPS[idx] = opcode;
     }
 }
diff --git a/dx/src/com/android/dx/dex/code/OddSpacer.java b/dx/src/com/android/dx/dex/code/OddSpacer.java
index 756a0e2bf..f44f9ccd9 100644
--- a/dx/src/com/android/dx/dex/code/OddSpacer.java
+++ b/dx/src/com/android/dx/dex/code/OddSpacer.java
@@ -16,6 +16,7 @@
 
 package com.android.dx.dex.code;
 
+import com.android.dx.io.Opcodes;
 import com.android.dx.rop.code.RegisterSpecList;
 import com.android.dx.rop.code.SourcePosition;
 import com.android.dx.util.AnnotatedOutput;
@@ -47,7 +48,7 @@ public final class OddSpacer extends VariableSizeInsn {
     @Override
     public void writeTo(AnnotatedOutput out) {
         if (codeSize() != 0) {
-            out.writeShort(InsnFormat.codeUnit(DalvOps.NOP, 0));
+            out.writeShort(InsnFormat.codeUnit(Opcodes.NOP, 0));
         }
     }
 
diff --git a/dx/src/com/android/dx/dex/code/OutputFinisher.java b/dx/src/com/android/dx/dex/code/OutputFinisher.java
index e52681743..118d18435 100644
--- a/dx/src/com/android/dx/dex/code/OutputFinisher.java
+++ b/dx/src/com/android/dx/dex/code/OutputFinisher.java
@@ -16,6 +16,7 @@
 
 package com.android.dx.dex.code;
 
+import com.android.dx.io.Opcodes;
 import com.android.dx.rop.code.LocalItem;
 import com.android.dx.rop.code.RegisterSpec;
 import com.android.dx.rop.code.RegisterSpecList;
@@ -681,7 +682,7 @@ public final class OutputFinisher {
                 continue;
             }
 
-            if (opcode.getFamily() == DalvOps.GOTO) {
+            if (opcode.getFamily() == Opcodes.GOTO) {
                 // It is a goto; widen it if possible.
                 opcode = findOpcodeForInsn(insn, opcode);
                 if (opcode == null) {
diff --git a/dx/src/com/android/dx/dex/code/RopToDop.java b/dx/src/com/android/dx/dex/code/RopToDop.java
index 6b9212603..5292d3cd5 100644
--- a/dx/src/com/android/dx/dex/code/RopToDop.java
+++ b/dx/src/com/android/dx/dex/code/RopToDop.java
@@ -57,163 +57,163 @@ public final class RopToDop {
      */
 
     // BEGIN(first-opcodes); GENERATED AUTOMATICALLY BY opcode-gen
-    //     DalvOps.NOP
-    //     DalvOps.MOVE
-    //     DalvOps.MOVE_WIDE
-    //     DalvOps.MOVE_OBJECT
-    //     DalvOps.MOVE_RESULT
-    //     DalvOps.MOVE_RESULT_WIDE
-    //     DalvOps.MOVE_RESULT_OBJECT
-    //     DalvOps.MOVE_EXCEPTION
-    //     DalvOps.RETURN_VOID
-    //     DalvOps.RETURN
-    //     DalvOps.RETURN_WIDE
-    //     DalvOps.RETURN_OBJECT
-    //     DalvOps.CONST_4
-    //     DalvOps.CONST_WIDE_16
-    //     DalvOps.CONST_STRING
-    //     DalvOps.CONST_CLASS
-    //     DalvOps.MONITOR_ENTER
-    //     DalvOps.MONITOR_EXIT
-    //     DalvOps.CHECK_CAST
-    //     DalvOps.INSTANCE_OF
-    //     DalvOps.ARRAY_LENGTH
-    //     DalvOps.NEW_INSTANCE
-    //     DalvOps.NEW_ARRAY
-    //     DalvOps.FILLED_NEW_ARRAY
-    //     DalvOps.FILL_ARRAY_DATA
-    //     DalvOps.THROW
-    //     DalvOps.GOTO
-    //     DalvOps.PACKED_SWITCH
-    //     DalvOps.SPARSE_SWITCH
-    //     DalvOps.CMPL_FLOAT
-    //     DalvOps.CMPG_FLOAT
-    //     DalvOps.CMPL_DOUBLE
-    //     DalvOps.CMPG_DOUBLE
-    //     DalvOps.CMP_LONG
-    //     DalvOps.IF_EQ
-    //     DalvOps.IF_NE
-    //     DalvOps.IF_LT
-    //     DalvOps.IF_GE
-    //     DalvOps.IF_GT
-    //     DalvOps.IF_LE
-    //     DalvOps.IF_EQZ
-    //     DalvOps.IF_NEZ
-    //     DalvOps.IF_LTZ
-    //     DalvOps.IF_GEZ
-    //     DalvOps.IF_GTZ
-    //     DalvOps.IF_LEZ
-    //     DalvOps.AGET
-    //     DalvOps.AGET_WIDE
-    //     DalvOps.AGET_OBJECT
-    //     DalvOps.AGET_BOOLEAN
-    //     DalvOps.AGET_BYTE
-    //     DalvOps.AGET_CHAR
-    //     DalvOps.AGET_SHORT
-    //     DalvOps.APUT
-    //     DalvOps.APUT_WIDE
-    //     DalvOps.APUT_OBJECT
-    //     DalvOps.APUT_BOOLEAN
-    //     DalvOps.APUT_BYTE
-    //     DalvOps.APUT_CHAR
-    //     DalvOps.APUT_SHORT
-    //     DalvOps.IGET
-    //     DalvOps.IGET_WIDE
-    //     DalvOps.IGET_OBJECT
-    //     DalvOps.IGET_BOOLEAN
-    //     DalvOps.IGET_BYTE
-    //     DalvOps.IGET_CHAR
-    //     DalvOps.IGET_SHORT
-    //     DalvOps.IPUT
-    //     DalvOps.IPUT_WIDE
-    //     DalvOps.IPUT_OBJECT
-    //     DalvOps.IPUT_BOOLEAN
-    //     DalvOps.IPUT_BYTE
-    //     DalvOps.IPUT_CHAR
-    //     DalvOps.IPUT_SHORT
-    //     DalvOps.SGET
-    //     DalvOps.SGET_WIDE
-    //     DalvOps.SGET_OBJECT
-    //     DalvOps.SGET_BOOLEAN
-    //     DalvOps.SGET_BYTE
-    //     DalvOps.SGET_CHAR
-    //     DalvOps.SGET_SHORT
-    //     DalvOps.SPUT
-    //     DalvOps.SPUT_WIDE
-    //     DalvOps.SPUT_OBJECT
-    //     DalvOps.SPUT_BOOLEAN
-    //     DalvOps.SPUT_BYTE
-    //     DalvOps.SPUT_CHAR
-    //     DalvOps.SPUT_SHORT
-    //     DalvOps.INVOKE_VIRTUAL
-    //     DalvOps.INVOKE_SUPER
-    //     DalvOps.INVOKE_DIRECT
-    //     DalvOps.INVOKE_STATIC
-    //     DalvOps.INVOKE_INTERFACE
-    //     DalvOps.NEG_INT
-    //     DalvOps.NOT_INT
-    //     DalvOps.NEG_LONG
-    //     DalvOps.NOT_LONG
-    //     DalvOps.NEG_FLOAT
-    //     DalvOps.NEG_DOUBLE
-    //     DalvOps.INT_TO_LONG
-    //     DalvOps.INT_TO_FLOAT
-    //     DalvOps.INT_TO_DOUBLE
-    //     DalvOps.LONG_TO_INT
-    //     DalvOps.LONG_TO_FLOAT
-    //     DalvOps.LONG_TO_DOUBLE
-    //     DalvOps.FLOAT_TO_INT
-    //     DalvOps.FLOAT_TO_LONG
-    //     DalvOps.FLOAT_TO_DOUBLE
-    //     DalvOps.DOUBLE_TO_INT
-    //     DalvOps.DOUBLE_TO_LONG
-    //     DalvOps.DOUBLE_TO_FLOAT
-    //     DalvOps.INT_TO_BYTE
-    //     DalvOps.INT_TO_CHAR
-    //     DalvOps.INT_TO_SHORT
-    //     DalvOps.ADD_INT_2ADDR
-    //     DalvOps.SUB_INT_2ADDR
-    //     DalvOps.MUL_INT_2ADDR
-    //     DalvOps.DIV_INT_2ADDR
-    //     DalvOps.REM_INT_2ADDR
-    //     DalvOps.AND_INT_2ADDR
-    //     DalvOps.OR_INT_2ADDR
-    //     DalvOps.XOR_INT_2ADDR
-    //     DalvOps.SHL_INT_2ADDR
-    //     DalvOps.SHR_INT_2ADDR
-    //     DalvOps.USHR_INT_2ADDR
-    //     DalvOps.ADD_LONG_2ADDR
-    //     DalvOps.SUB_LONG_2ADDR
-    //     DalvOps.MUL_LONG_2ADDR
-    //     DalvOps.DIV_LONG_2ADDR
-    //     DalvOps.REM_LONG_2ADDR
-    //     DalvOps.AND_LONG_2ADDR
-    //     DalvOps.OR_LONG_2ADDR
-    //     DalvOps.XOR_LONG_2ADDR
-    //     DalvOps.SHL_LONG_2ADDR
-    //     DalvOps.SHR_LONG_2ADDR
-    //     DalvOps.USHR_LONG_2ADDR
-    //     DalvOps.ADD_FLOAT_2ADDR
-    //     DalvOps.SUB_FLOAT_2ADDR
-    //     DalvOps.MUL_FLOAT_2ADDR
-    //     DalvOps.DIV_FLOAT_2ADDR
-    //     DalvOps.REM_FLOAT_2ADDR
-    //     DalvOps.ADD_DOUBLE_2ADDR
-    //     DalvOps.SUB_DOUBLE_2ADDR
-    //     DalvOps.MUL_DOUBLE_2ADDR
-    //     DalvOps.DIV_DOUBLE_2ADDR
-    //     DalvOps.REM_DOUBLE_2ADDR
-    //     DalvOps.ADD_INT_LIT8
-    //     DalvOps.RSUB_INT_LIT8
-    //     DalvOps.MUL_INT_LIT8
-    //     DalvOps.DIV_INT_LIT8
-    //     DalvOps.REM_INT_LIT8
-    //     DalvOps.AND_INT_LIT8
-    //     DalvOps.OR_INT_LIT8
-    //     DalvOps.XOR_INT_LIT8
-    //     DalvOps.SHL_INT_LIT8
-    //     DalvOps.SHR_INT_LIT8
-    //     DalvOps.USHR_INT_LIT8
+    //     Opcodes.NOP
+    //     Opcodes.MOVE
+    //     Opcodes.MOVE_WIDE
+    //     Opcodes.MOVE_OBJECT
+    //     Opcodes.MOVE_RESULT
+    //     Opcodes.MOVE_RESULT_WIDE
+    //     Opcodes.MOVE_RESULT_OBJECT
+    //     Opcodes.MOVE_EXCEPTION
+    //     Opcodes.RETURN_VOID
+    //     Opcodes.RETURN
+    //     Opcodes.RETURN_WIDE
+    //     Opcodes.RETURN_OBJECT
+    //     Opcodes.CONST_4
+    //     Opcodes.CONST_WIDE_16
+    //     Opcodes.CONST_STRING
+    //     Opcodes.CONST_CLASS
+    //     Opcodes.MONITOR_ENTER
+    //     Opcodes.MONITOR_EXIT
+    //     Opcodes.CHECK_CAST
+    //     Opcodes.INSTANCE_OF
+    //     Opcodes.ARRAY_LENGTH
+    //     Opcodes.NEW_INSTANCE
+    //     Opcodes.NEW_ARRAY
+    //     Opcodes.FILLED_NEW_ARRAY
+    //     Opcodes.FILL_ARRAY_DATA
+    //     Opcodes.THROW
+    //     Opcodes.GOTO
+    //     Opcodes.PACKED_SWITCH
+    //     Opcodes.SPARSE_SWITCH
+    //     Opcodes.CMPL_FLOAT
+    //     Opcodes.CMPG_FLOAT
+    //     Opcodes.CMPL_DOUBLE
+    //     Opcodes.CMPG_DOUBLE
+    //     Opcodes.CMP_LONG
+    //     Opcodes.IF_EQ
+    //     Opcodes.IF_NE
+    //     Opcodes.IF_LT
+    //     Opcodes.IF_GE
+    //     Opcodes.IF_GT
+    //     Opcodes.IF_LE
+    //     Opcodes.IF_EQZ
+    //     Opcodes.IF_NEZ
+    //     Opcodes.IF_LTZ
+    //     Opcodes.IF_GEZ
+    //     Opcodes.IF_GTZ
+    //     Opcodes.IF_LEZ
+    //     Opcodes.AGET
+    //     Opcodes.AGET_WIDE
+    //     Opcodes.AGET_OBJECT
+    //     Opcodes.AGET_BOOLEAN
+    //     Opcodes.AGET_BYTE
+    //     Opcodes.AGET_CHAR
+    //     Opcodes.AGET_SHORT
+    //     Opcodes.APUT
+    //     Opcodes.APUT_WIDE
+    //     Opcodes.APUT_OBJECT
+    //     Opcodes.APUT_BOOLEAN
+    //     Opcodes.APUT_BYTE
+    //     Opcodes.APUT_CHAR
+    //     Opcodes.APUT_SHORT
+    //     Opcodes.IGET
+    //     Opcodes.IGET_WIDE
+    //     Opcodes.IGET_OBJECT
+    //     Opcodes.IGET_BOOLEAN
+    //     Opcodes.IGET_BYTE
+    //     Opcodes.IGET_CHAR
+    //     Opcodes.IGET_SHORT
+    //     Opcodes.IPUT
+    //     Opcodes.IPUT_WIDE
+    //     Opcodes.IPUT_OBJECT
+    //     Opcodes.IPUT_BOOLEAN
+    //     Opcodes.IPUT_BYTE
+    //     Opcodes.IPUT_CHAR
+    //     Opcodes.IPUT_SHORT
+    //     Opcodes.SGET
+    //     Opcodes.SGET_WIDE
+    //     Opcodes.SGET_OBJECT
+    //     Opcodes.SGET_BOOLEAN
+    //     Opcodes.SGET_BYTE
+    //     Opcodes.SGET_CHAR
+    //     Opcodes.SGET_SHORT
+    //     Opcodes.SPUT
+    //     Opcodes.SPUT_WIDE
+    //     Opcodes.SPUT_OBJECT
+    //     Opcodes.SPUT_BOOLEAN
+    //     Opcodes.SPUT_BYTE
+    //     Opcodes.SPUT_CHAR
+    //     Opcodes.SPUT_SHORT
+    //     Opcodes.INVOKE_VIRTUAL
+    //     Opcodes.INVOKE_SUPER
+    //     Opcodes.INVOKE_DIRECT
+    //     Opcodes.INVOKE_STATIC
+    //     Opcodes.INVOKE_INTERFACE
+    //     Opcodes.NEG_INT
+    //     Opcodes.NOT_INT
+    //     Opcodes.NEG_LONG
+    //     Opcodes.NOT_LONG
+    //     Opcodes.NEG_FLOAT
+    //     Opcodes.NEG_DOUBLE
+    //     Opcodes.INT_TO_LONG
+    //     Opcodes.INT_TO_FLOAT
+    //     Opcodes.INT_TO_DOUBLE
+    //     Opcodes.LONG_TO_INT
+    //     Opcodes.LONG_TO_FLOAT
+    //     Opcodes.LONG_TO_DOUBLE
+    //     Opcodes.FLOAT_TO_INT
+    //     Opcodes.FLOAT_TO_LONG
+    //     Opcodes.FLOAT_TO_DOUBLE
+    //     Opcodes.DOUBLE_TO_INT
+    //     Opcodes.DOUBLE_TO_LONG
+    //     Opcodes.DOUBLE_TO_FLOAT
+    //     Opcodes.INT_TO_BYTE
+    //     Opcodes.INT_TO_CHAR
+    //     Opcodes.INT_TO_SHORT
+    //     Opcodes.ADD_INT_2ADDR
+    //     Opcodes.SUB_INT_2ADDR
+    //     Opcodes.MUL_INT_2ADDR
+    //     Opcodes.DIV_INT_2ADDR
+    //     Opcodes.REM_INT_2ADDR
+    //     Opcodes.AND_INT_2ADDR
+    //     Opcodes.OR_INT_2ADDR
+    //     Opcodes.XOR_INT_2ADDR
+    //     Opcodes.SHL_INT_2ADDR
+    //     Opcodes.SHR_INT_2ADDR
+    //     Opcodes.USHR_INT_2ADDR
+    //     Opcodes.ADD_LONG_2ADDR
+    //     Opcodes.SUB_LONG_2ADDR
+    //     Opcodes.MUL_LONG_2ADDR
+    //     Opcodes.DIV_LONG_2ADDR
+    //     Opcodes.REM_LONG_2ADDR
+    //     Opcodes.AND_LONG_2ADDR
+    //     Opcodes.OR_LONG_2ADDR
+    //     Opcodes.XOR_LONG_2ADDR
+    //     Opcodes.SHL_LONG_2ADDR
+    //     Opcodes.SHR_LONG_2ADDR
+    //     Opcodes.USHR_LONG_2ADDR
+    //     Opcodes.ADD_FLOAT_2ADDR
+    //     Opcodes.SUB_FLOAT_2ADDR
+    //     Opcodes.MUL_FLOAT_2ADDR
+    //     Opcodes.DIV_FLOAT_2ADDR
+    //     Opcodes.REM_FLOAT_2ADDR
+    //     Opcodes.ADD_DOUBLE_2ADDR
+    //     Opcodes.SUB_DOUBLE_2ADDR
+    //     Opcodes.MUL_DOUBLE_2ADDR
+    //     Opcodes.DIV_DOUBLE_2ADDR
+    //     Opcodes.REM_DOUBLE_2ADDR
+    //     Opcodes.ADD_INT_LIT8
+    //     Opcodes.RSUB_INT_LIT8
+    //     Opcodes.MUL_INT_LIT8
+    //     Opcodes.DIV_INT_LIT8
+    //     Opcodes.REM_INT_LIT8
+    //     Opcodes.AND_INT_LIT8
+    //     Opcodes.OR_INT_LIT8
+    //     Opcodes.XOR_INT_LIT8
+    //     Opcodes.SHL_INT_LIT8
+    //     Opcodes.SHR_INT_LIT8
+    //     Opcodes.USHR_INT_LIT8
     // END(first-opcodes)
 
     static {
diff --git a/dx/src/com/android/dx/dex/code/RopTranslator.java b/dx/src/com/android/dx/dex/code/RopTranslator.java
index 2eb6454d3..a91247f82 100644
--- a/dx/src/com/android/dx/dex/code/RopTranslator.java
+++ b/dx/src/com/android/dx/dex/code/RopTranslator.java
@@ -16,6 +16,7 @@
 
 package com.android.dx.dex.code;
 
+import com.android.dx.io.Opcodes;
 import com.android.dx.rop.code.BasicBlock;
 import com.android.dx.rop.code.BasicBlockList;
 import com.android.dx.rop.code.FillArrayDataInsn;
@@ -710,7 +711,7 @@ public final class RopTranslator {
                 }
 
                 if ((rop.getOpcode() == RegOps.NEW_ARRAY) &&
-                    (opcode.getOpcode() != DalvOps.NEW_ARRAY)) {
+                    (opcode.getOpcode() != Opcodes.NEW_ARRAY)) {
                     /*
                      * It's a type-specific new-array-<primitive>, and
                      * so it should be turned into a SimpleInsn (no
diff --git a/dx/src/com/android/dx/dex/code/SwitchData.java b/dx/src/com/android/dx/dex/code/SwitchData.java
index 27a6342f7..8fc80b1ca 100644
--- a/dx/src/com/android/dx/dex/code/SwitchData.java
+++ b/dx/src/com/android/dx/dex/code/SwitchData.java
@@ -16,6 +16,7 @@
 
 package com.android.dx.dex.code;
 
+import com.android.dx.io.Opcodes;
 import com.android.dx.rop.code.RegisterSpecList;
 import com.android.dx.rop.code.SourcePosition;
 import com.android.dx.util.AnnotatedOutput;
@@ -108,7 +109,7 @@ public final class SwitchData extends VariableSizeInsn {
             int lastCase = (sz == 0) ? 0 : cases.get(sz - 1);
             int outSz = lastCase - firstCase + 1;
 
-            out.writeShort(0x100 | DalvOps.NOP);
+            out.writeShort(Opcodes.PACKED_SWITCH_PAYLOAD);
             out.writeShort(outSz);
             out.writeInt(firstCase);
 
@@ -128,7 +129,7 @@ public final class SwitchData extends VariableSizeInsn {
                 out.writeInt(relTarget);
             }
         } else {
-            out.writeShort(0x200 | DalvOps.NOP);
+            out.writeShort(Opcodes.SPARSE_SWITCH_PAYLOAD);
             out.writeShort(sz);
 
             for (int i = 0; i < sz; i++) {
@@ -181,7 +182,7 @@ public final class SwitchData extends VariableSizeInsn {
         int sz = targets.length;
 
         sb.append(packed ? "packed" : "sparse");
-        sb.append("-switch-data // for switch @ ");
+        sb.append("-switch-payload // for switch @ ");
         sb.append(Hex.u2(baseAddress));
 
         for (int i = 0; i < sz; i++) {
diff --git a/dx/src/com/android/dx/dex/code/form/SpecialFormat.java b/dx/src/com/android/dx/dex/code/form/SpecialFormat.java
index 2d04964f5..87091b5a3 100644
--- a/dx/src/com/android/dx/dex/code/form/SpecialFormat.java
+++ b/dx/src/com/android/dx/dex/code/form/SpecialFormat.java
@@ -17,7 +17,6 @@
 package com.android.dx.dex.code.form;
 
 import com.android.dx.dex.code.DalvInsn;
-import com.android.dx.dex.code.DalvOps;
 import com.android.dx.dex.code.InsnFormat;
 import com.android.dx.util.AnnotatedOutput;
 
diff --git a/dx/src/com/android/dx/io/DecodedInstruction.java b/dx/src/com/android/dx/io/DecodedInstruction.java
index 1cb6427db..23426dd37 100644
--- a/dx/src/com/android/dx/io/DecodedInstruction.java
+++ b/dx/src/com/android/dx/io/DecodedInstruction.java
@@ -16,9 +16,6 @@
 
 package com.android.dx.io;
 
-// TODO: DalvOps should migrate to this package (and get a better name).
-import com.android.dx.dex.code.DalvOps;
-
 /**
  * A decoded Dalvik instruction. This consists of a format codec, a
  * numeric opcode, an optional index type, and any additional
@@ -88,7 +85,7 @@ public final class DecodedInstruction {
             throw new NullPointerException("format == null");
         }
 
-        if (!DalvOps.isValidShape(opcode)) {
+        if (!Opcodes.isValidShape(opcode)) {
             throw new IllegalArgumentException("invalid opcode");
         }
 
diff --git a/dx/src/com/android/dx/io/InstructionCodec.java b/dx/src/com/android/dx/io/InstructionCodec.java
index 6277ad385..03917040b 100644
--- a/dx/src/com/android/dx/io/InstructionCodec.java
+++ b/dx/src/com/android/dx/io/InstructionCodec.java
@@ -16,8 +16,6 @@
 
 package com.android.dx.io;
 
-import com.android.dx.dex.code.DalvOps;
-
 /**
  * Representation of an instruction format, which knows how to decode into
  * and encode from instances of {@link DecodedInstruction}.
@@ -219,7 +217,7 @@ public enum InstructionCodec {
              * because the "signed hat" might represent either a 32-
              * or 64- bit value.
              */
-            literal <<= (opcode == DalvOps.CONST_HIGH16) ? 16 : 48;
+            literal <<= (opcode == Opcodes.CONST_HIGH16) ? 16 : 48;
 
             return new DecodedInstruction(this, opcode, 0, null,
                     0, literal, null,
@@ -229,7 +227,7 @@ public enum InstructionCodec {
         @Override public void encode(DecodedInstruction insn, CodeOutput out) {
             // See above.
             int opcode = insn.getOpcode();
-            int shift = (opcode == DalvOps.CONST_HIGH16) ? 16 : 48;
+            int shift = (opcode == Opcodes.CONST_HIGH16) ? 16 : 48;
             short literal = (short) (insn.getLiteral() >> shift);
 
             out.write(codeUnit(opcode, insn.getA()), literal);
diff --git a/dx/src/com/android/dx/io/OpcodeInfo.java b/dx/src/com/android/dx/io/OpcodeInfo.java
index cdb04b4c6..7359decf1 100644
--- a/dx/src/com/android/dx/io/OpcodeInfo.java
+++ b/dx/src/com/android/dx/io/OpcodeInfo.java
@@ -16,7 +16,6 @@
 
 package com.android.dx.io;
 
-import com.android.dx.dex.code.DalvOps;
 import com.android.dx.util.Hex;
 
 /**
@@ -33,1038 +32,1038 @@ public final class OpcodeInfo {
 
     // BEGIN(opcode-info-defs); GENERATED AUTOMATICALLY BY opcode-gen
     public static final Info NOP =
-        new Info(DalvOps.NOP,
+        new Info(Opcodes.NOP,
             InstructionCodec.FORMAT_10X, null);
 
     public static final Info MOVE =
-        new Info(DalvOps.MOVE,
+        new Info(Opcodes.MOVE,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info MOVE_FROM16 =
-        new Info(DalvOps.MOVE_FROM16,
+        new Info(Opcodes.MOVE_FROM16,
             InstructionCodec.FORMAT_22X, null);
 
     public static final Info MOVE_16 =
-        new Info(DalvOps.MOVE_16,
+        new Info(Opcodes.MOVE_16,
             InstructionCodec.FORMAT_32X, null);
 
     public static final Info MOVE_WIDE =
-        new Info(DalvOps.MOVE_WIDE,
+        new Info(Opcodes.MOVE_WIDE,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info MOVE_WIDE_FROM16 =
-        new Info(DalvOps.MOVE_WIDE_FROM16,
+        new Info(Opcodes.MOVE_WIDE_FROM16,
             InstructionCodec.FORMAT_22X, null);
 
     public static final Info MOVE_WIDE_16 =
-        new Info(DalvOps.MOVE_WIDE_16,
+        new Info(Opcodes.MOVE_WIDE_16,
             InstructionCodec.FORMAT_32X, null);
 
     public static final Info MOVE_OBJECT =
-        new Info(DalvOps.MOVE_OBJECT,
+        new Info(Opcodes.MOVE_OBJECT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info MOVE_OBJECT_FROM16 =
-        new Info(DalvOps.MOVE_OBJECT_FROM16,
+        new Info(Opcodes.MOVE_OBJECT_FROM16,
             InstructionCodec.FORMAT_22X, null);
 
     public static final Info MOVE_OBJECT_16 =
-        new Info(DalvOps.MOVE_OBJECT_16,
+        new Info(Opcodes.MOVE_OBJECT_16,
             InstructionCodec.FORMAT_32X, null);
 
     public static final Info MOVE_RESULT =
-        new Info(DalvOps.MOVE_RESULT,
+        new Info(Opcodes.MOVE_RESULT,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info MOVE_RESULT_WIDE =
-        new Info(DalvOps.MOVE_RESULT_WIDE,
+        new Info(Opcodes.MOVE_RESULT_WIDE,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info MOVE_RESULT_OBJECT =
-        new Info(DalvOps.MOVE_RESULT_OBJECT,
+        new Info(Opcodes.MOVE_RESULT_OBJECT,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info MOVE_EXCEPTION =
-        new Info(DalvOps.MOVE_EXCEPTION,
+        new Info(Opcodes.MOVE_EXCEPTION,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info RETURN_VOID =
-        new Info(DalvOps.RETURN_VOID,
+        new Info(Opcodes.RETURN_VOID,
             InstructionCodec.FORMAT_10X, null);
 
     public static final Info RETURN =
-        new Info(DalvOps.RETURN,
+        new Info(Opcodes.RETURN,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info RETURN_WIDE =
-        new Info(DalvOps.RETURN_WIDE,
+        new Info(Opcodes.RETURN_WIDE,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info RETURN_OBJECT =
-        new Info(DalvOps.RETURN_OBJECT,
+        new Info(Opcodes.RETURN_OBJECT,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info CONST_4 =
-        new Info(DalvOps.CONST_4,
+        new Info(Opcodes.CONST_4,
             InstructionCodec.FORMAT_11N, null);
 
     public static final Info CONST_16 =
-        new Info(DalvOps.CONST_16,
+        new Info(Opcodes.CONST_16,
             InstructionCodec.FORMAT_21S, null);
 
     public static final Info CONST =
-        new Info(DalvOps.CONST,
+        new Info(Opcodes.CONST,
             InstructionCodec.FORMAT_31I, null);
 
     public static final Info CONST_HIGH16 =
-        new Info(DalvOps.CONST_HIGH16,
+        new Info(Opcodes.CONST_HIGH16,
             InstructionCodec.FORMAT_21H, null);
 
     public static final Info CONST_WIDE_16 =
-        new Info(DalvOps.CONST_WIDE_16,
+        new Info(Opcodes.CONST_WIDE_16,
             InstructionCodec.FORMAT_21S, null);
 
     public static final Info CONST_WIDE_32 =
-        new Info(DalvOps.CONST_WIDE_32,
+        new Info(Opcodes.CONST_WIDE_32,
             InstructionCodec.FORMAT_31I, null);
 
     public static final Info CONST_WIDE =
-        new Info(DalvOps.CONST_WIDE,
+        new Info(Opcodes.CONST_WIDE,
             InstructionCodec.FORMAT_51L, null);
 
     public static final Info CONST_WIDE_HIGH16 =
-        new Info(DalvOps.CONST_WIDE_HIGH16,
+        new Info(Opcodes.CONST_WIDE_HIGH16,
             InstructionCodec.FORMAT_21H, null);
 
     public static final Info CONST_STRING =
-        new Info(DalvOps.CONST_STRING,
+        new Info(Opcodes.CONST_STRING,
             InstructionCodec.FORMAT_21C, IndexType.STRING_REF);
 
     public static final Info CONST_STRING_JUMBO =
-        new Info(DalvOps.CONST_STRING_JUMBO,
+        new Info(Opcodes.CONST_STRING_JUMBO,
             InstructionCodec.FORMAT_31C, IndexType.STRING_REF);
 
     public static final Info CONST_CLASS =
-        new Info(DalvOps.CONST_CLASS,
+        new Info(Opcodes.CONST_CLASS,
             InstructionCodec.FORMAT_21C, IndexType.TYPE_REF);
 
     public static final Info MONITOR_ENTER =
-        new Info(DalvOps.MONITOR_ENTER,
+        new Info(Opcodes.MONITOR_ENTER,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info MONITOR_EXIT =
-        new Info(DalvOps.MONITOR_EXIT,
+        new Info(Opcodes.MONITOR_EXIT,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info CHECK_CAST =
-        new Info(DalvOps.CHECK_CAST,
+        new Info(Opcodes.CHECK_CAST,
             InstructionCodec.FORMAT_21C, IndexType.TYPE_REF);
 
     public static final Info INSTANCE_OF =
-        new Info(DalvOps.INSTANCE_OF,
+        new Info(Opcodes.INSTANCE_OF,
             InstructionCodec.FORMAT_22C, IndexType.TYPE_REF);
 
     public static final Info ARRAY_LENGTH =
-        new Info(DalvOps.ARRAY_LENGTH,
+        new Info(Opcodes.ARRAY_LENGTH,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info NEW_INSTANCE =
-        new Info(DalvOps.NEW_INSTANCE,
+        new Info(Opcodes.NEW_INSTANCE,
             InstructionCodec.FORMAT_21C, IndexType.TYPE_REF);
 
     public static final Info NEW_ARRAY =
-        new Info(DalvOps.NEW_ARRAY,
+        new Info(Opcodes.NEW_ARRAY,
             InstructionCodec.FORMAT_22C, IndexType.TYPE_REF);
 
     public static final Info FILLED_NEW_ARRAY =
-        new Info(DalvOps.FILLED_NEW_ARRAY,
+        new Info(Opcodes.FILLED_NEW_ARRAY,
             InstructionCodec.FORMAT_35C, IndexType.TYPE_REF);
 
     public static final Info FILLED_NEW_ARRAY_RANGE =
-        new Info(DalvOps.FILLED_NEW_ARRAY_RANGE,
+        new Info(Opcodes.FILLED_NEW_ARRAY_RANGE,
             InstructionCodec.FORMAT_3RC, IndexType.TYPE_REF);
 
     public static final Info FILL_ARRAY_DATA =
-        new Info(DalvOps.FILL_ARRAY_DATA,
+        new Info(Opcodes.FILL_ARRAY_DATA,
             InstructionCodec.FORMAT_31T, null);
 
     public static final Info THROW =
-        new Info(DalvOps.THROW,
+        new Info(Opcodes.THROW,
             InstructionCodec.FORMAT_11X, null);
 
     public static final Info GOTO =
-        new Info(DalvOps.GOTO,
+        new Info(Opcodes.GOTO,
             InstructionCodec.FORMAT_10T, null);
 
     public static final Info GOTO_16 =
-        new Info(DalvOps.GOTO_16,
+        new Info(Opcodes.GOTO_16,
             InstructionCodec.FORMAT_20T, null);
 
     public static final Info GOTO_32 =
-        new Info(DalvOps.GOTO_32,
+        new Info(Opcodes.GOTO_32,
             InstructionCodec.FORMAT_30T, null);
 
     public static final Info PACKED_SWITCH =
-        new Info(DalvOps.PACKED_SWITCH,
+        new Info(Opcodes.PACKED_SWITCH,
             InstructionCodec.FORMAT_31T, null);
 
     public static final Info SPARSE_SWITCH =
-        new Info(DalvOps.SPARSE_SWITCH,
+        new Info(Opcodes.SPARSE_SWITCH,
             InstructionCodec.FORMAT_31T, null);
 
     public static final Info CMPL_FLOAT =
-        new Info(DalvOps.CMPL_FLOAT,
+        new Info(Opcodes.CMPL_FLOAT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info CMPG_FLOAT =
-        new Info(DalvOps.CMPG_FLOAT,
+        new Info(Opcodes.CMPG_FLOAT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info CMPL_DOUBLE =
-        new Info(DalvOps.CMPL_DOUBLE,
+        new Info(Opcodes.CMPL_DOUBLE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info CMPG_DOUBLE =
-        new Info(DalvOps.CMPG_DOUBLE,
+        new Info(Opcodes.CMPG_DOUBLE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info CMP_LONG =
-        new Info(DalvOps.CMP_LONG,
+        new Info(Opcodes.CMP_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info IF_EQ =
-        new Info(DalvOps.IF_EQ,
+        new Info(Opcodes.IF_EQ,
             InstructionCodec.FORMAT_22T, null);
 
     public static final Info IF_NE =
-        new Info(DalvOps.IF_NE,
+        new Info(Opcodes.IF_NE,
             InstructionCodec.FORMAT_22T, null);
 
     public static final Info IF_LT =
-        new Info(DalvOps.IF_LT,
+        new Info(Opcodes.IF_LT,
             InstructionCodec.FORMAT_22T, null);
 
     public static final Info IF_GE =
-        new Info(DalvOps.IF_GE,
+        new Info(Opcodes.IF_GE,
             InstructionCodec.FORMAT_22T, null);
 
     public static final Info IF_GT =
-        new Info(DalvOps.IF_GT,
+        new Info(Opcodes.IF_GT,
             InstructionCodec.FORMAT_22T, null);
 
     public static final Info IF_LE =
-        new Info(DalvOps.IF_LE,
+        new Info(Opcodes.IF_LE,
             InstructionCodec.FORMAT_22T, null);
 
     public static final Info IF_EQZ =
-        new Info(DalvOps.IF_EQZ,
+        new Info(Opcodes.IF_EQZ,
             InstructionCodec.FORMAT_21T, null);
 
     public static final Info IF_NEZ =
-        new Info(DalvOps.IF_NEZ,
+        new Info(Opcodes.IF_NEZ,
             InstructionCodec.FORMAT_21T, null);
 
     public static final Info IF_LTZ =
-        new Info(DalvOps.IF_LTZ,
+        new Info(Opcodes.IF_LTZ,
             InstructionCodec.FORMAT_21T, null);
 
     public static final Info IF_GEZ =
-        new Info(DalvOps.IF_GEZ,
+        new Info(Opcodes.IF_GEZ,
             InstructionCodec.FORMAT_21T, null);
 
     public static final Info IF_GTZ =
-        new Info(DalvOps.IF_GTZ,
+        new Info(Opcodes.IF_GTZ,
             InstructionCodec.FORMAT_21T, null);
 
     public static final Info IF_LEZ =
-        new Info(DalvOps.IF_LEZ,
+        new Info(Opcodes.IF_LEZ,
             InstructionCodec.FORMAT_21T, null);
 
     public static final Info AGET =
-        new Info(DalvOps.AGET,
+        new Info(Opcodes.AGET,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info AGET_WIDE =
-        new Info(DalvOps.AGET_WIDE,
+        new Info(Opcodes.AGET_WIDE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info AGET_OBJECT =
-        new Info(DalvOps.AGET_OBJECT,
+        new Info(Opcodes.AGET_OBJECT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info AGET_BOOLEAN =
-        new Info(DalvOps.AGET_BOOLEAN,
+        new Info(Opcodes.AGET_BOOLEAN,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info AGET_BYTE =
-        new Info(DalvOps.AGET_BYTE,
+        new Info(Opcodes.AGET_BYTE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info AGET_CHAR =
-        new Info(DalvOps.AGET_CHAR,
+        new Info(Opcodes.AGET_CHAR,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info AGET_SHORT =
-        new Info(DalvOps.AGET_SHORT,
+        new Info(Opcodes.AGET_SHORT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info APUT =
-        new Info(DalvOps.APUT,
+        new Info(Opcodes.APUT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info APUT_WIDE =
-        new Info(DalvOps.APUT_WIDE,
+        new Info(Opcodes.APUT_WIDE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info APUT_OBJECT =
-        new Info(DalvOps.APUT_OBJECT,
+        new Info(Opcodes.APUT_OBJECT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info APUT_BOOLEAN =
-        new Info(DalvOps.APUT_BOOLEAN,
+        new Info(Opcodes.APUT_BOOLEAN,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info APUT_BYTE =
-        new Info(DalvOps.APUT_BYTE,
+        new Info(Opcodes.APUT_BYTE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info APUT_CHAR =
-        new Info(DalvOps.APUT_CHAR,
+        new Info(Opcodes.APUT_CHAR,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info APUT_SHORT =
-        new Info(DalvOps.APUT_SHORT,
+        new Info(Opcodes.APUT_SHORT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info IGET =
-        new Info(DalvOps.IGET,
+        new Info(Opcodes.IGET,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IGET_WIDE =
-        new Info(DalvOps.IGET_WIDE,
+        new Info(Opcodes.IGET_WIDE,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IGET_OBJECT =
-        new Info(DalvOps.IGET_OBJECT,
+        new Info(Opcodes.IGET_OBJECT,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IGET_BOOLEAN =
-        new Info(DalvOps.IGET_BOOLEAN,
+        new Info(Opcodes.IGET_BOOLEAN,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IGET_BYTE =
-        new Info(DalvOps.IGET_BYTE,
+        new Info(Opcodes.IGET_BYTE,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IGET_CHAR =
-        new Info(DalvOps.IGET_CHAR,
+        new Info(Opcodes.IGET_CHAR,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IGET_SHORT =
-        new Info(DalvOps.IGET_SHORT,
+        new Info(Opcodes.IGET_SHORT,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IPUT =
-        new Info(DalvOps.IPUT,
+        new Info(Opcodes.IPUT,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IPUT_WIDE =
-        new Info(DalvOps.IPUT_WIDE,
+        new Info(Opcodes.IPUT_WIDE,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IPUT_OBJECT =
-        new Info(DalvOps.IPUT_OBJECT,
+        new Info(Opcodes.IPUT_OBJECT,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IPUT_BOOLEAN =
-        new Info(DalvOps.IPUT_BOOLEAN,
+        new Info(Opcodes.IPUT_BOOLEAN,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IPUT_BYTE =
-        new Info(DalvOps.IPUT_BYTE,
+        new Info(Opcodes.IPUT_BYTE,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IPUT_CHAR =
-        new Info(DalvOps.IPUT_CHAR,
+        new Info(Opcodes.IPUT_CHAR,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info IPUT_SHORT =
-        new Info(DalvOps.IPUT_SHORT,
+        new Info(Opcodes.IPUT_SHORT,
             InstructionCodec.FORMAT_22C, IndexType.FIELD_REF);
 
     public static final Info SGET =
-        new Info(DalvOps.SGET,
+        new Info(Opcodes.SGET,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SGET_WIDE =
-        new Info(DalvOps.SGET_WIDE,
+        new Info(Opcodes.SGET_WIDE,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SGET_OBJECT =
-        new Info(DalvOps.SGET_OBJECT,
+        new Info(Opcodes.SGET_OBJECT,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SGET_BOOLEAN =
-        new Info(DalvOps.SGET_BOOLEAN,
+        new Info(Opcodes.SGET_BOOLEAN,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SGET_BYTE =
-        new Info(DalvOps.SGET_BYTE,
+        new Info(Opcodes.SGET_BYTE,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SGET_CHAR =
-        new Info(DalvOps.SGET_CHAR,
+        new Info(Opcodes.SGET_CHAR,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SGET_SHORT =
-        new Info(DalvOps.SGET_SHORT,
+        new Info(Opcodes.SGET_SHORT,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SPUT =
-        new Info(DalvOps.SPUT,
+        new Info(Opcodes.SPUT,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SPUT_WIDE =
-        new Info(DalvOps.SPUT_WIDE,
+        new Info(Opcodes.SPUT_WIDE,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SPUT_OBJECT =
-        new Info(DalvOps.SPUT_OBJECT,
+        new Info(Opcodes.SPUT_OBJECT,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SPUT_BOOLEAN =
-        new Info(DalvOps.SPUT_BOOLEAN,
+        new Info(Opcodes.SPUT_BOOLEAN,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SPUT_BYTE =
-        new Info(DalvOps.SPUT_BYTE,
+        new Info(Opcodes.SPUT_BYTE,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SPUT_CHAR =
-        new Info(DalvOps.SPUT_CHAR,
+        new Info(Opcodes.SPUT_CHAR,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info SPUT_SHORT =
-        new Info(DalvOps.SPUT_SHORT,
+        new Info(Opcodes.SPUT_SHORT,
             InstructionCodec.FORMAT_21C, IndexType.FIELD_REF);
 
     public static final Info INVOKE_VIRTUAL =
-        new Info(DalvOps.INVOKE_VIRTUAL,
+        new Info(Opcodes.INVOKE_VIRTUAL,
             InstructionCodec.FORMAT_35C, IndexType.METHOD_REF);
 
     public static final Info INVOKE_SUPER =
-        new Info(DalvOps.INVOKE_SUPER,
+        new Info(Opcodes.INVOKE_SUPER,
             InstructionCodec.FORMAT_35C, IndexType.METHOD_REF);
 
     public static final Info INVOKE_DIRECT =
-        new Info(DalvOps.INVOKE_DIRECT,
+        new Info(Opcodes.INVOKE_DIRECT,
             InstructionCodec.FORMAT_35C, IndexType.METHOD_REF);
 
     public static final Info INVOKE_STATIC =
-        new Info(DalvOps.INVOKE_STATIC,
+        new Info(Opcodes.INVOKE_STATIC,
             InstructionCodec.FORMAT_35C, IndexType.METHOD_REF);
 
     public static final Info INVOKE_INTERFACE =
-        new Info(DalvOps.INVOKE_INTERFACE,
+        new Info(Opcodes.INVOKE_INTERFACE,
             InstructionCodec.FORMAT_35C, IndexType.METHOD_REF);
 
     public static final Info INVOKE_VIRTUAL_RANGE =
-        new Info(DalvOps.INVOKE_VIRTUAL_RANGE,
+        new Info(Opcodes.INVOKE_VIRTUAL_RANGE,
             InstructionCodec.FORMAT_3RC, IndexType.METHOD_REF);
 
     public static final Info INVOKE_SUPER_RANGE =
-        new Info(DalvOps.INVOKE_SUPER_RANGE,
+        new Info(Opcodes.INVOKE_SUPER_RANGE,
             InstructionCodec.FORMAT_3RC, IndexType.METHOD_REF);
 
     public static final Info INVOKE_DIRECT_RANGE =
-        new Info(DalvOps.INVOKE_DIRECT_RANGE,
+        new Info(Opcodes.INVOKE_DIRECT_RANGE,
             InstructionCodec.FORMAT_3RC, IndexType.METHOD_REF);
 
     public static final Info INVOKE_STATIC_RANGE =
-        new Info(DalvOps.INVOKE_STATIC_RANGE,
+        new Info(Opcodes.INVOKE_STATIC_RANGE,
             InstructionCodec.FORMAT_3RC, IndexType.METHOD_REF);
 
     public static final Info INVOKE_INTERFACE_RANGE =
-        new Info(DalvOps.INVOKE_INTERFACE_RANGE,
+        new Info(Opcodes.INVOKE_INTERFACE_RANGE,
             InstructionCodec.FORMAT_3RC, IndexType.METHOD_REF);
 
     public static final Info NEG_INT =
-        new Info(DalvOps.NEG_INT,
+        new Info(Opcodes.NEG_INT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info NOT_INT =
-        new Info(DalvOps.NOT_INT,
+        new Info(Opcodes.NOT_INT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info NEG_LONG =
-        new Info(DalvOps.NEG_LONG,
+        new Info(Opcodes.NEG_LONG,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info NOT_LONG =
-        new Info(DalvOps.NOT_LONG,
+        new Info(Opcodes.NOT_LONG,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info NEG_FLOAT =
-        new Info(DalvOps.NEG_FLOAT,
+        new Info(Opcodes.NEG_FLOAT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info NEG_DOUBLE =
-        new Info(DalvOps.NEG_DOUBLE,
+        new Info(Opcodes.NEG_DOUBLE,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info INT_TO_LONG =
-        new Info(DalvOps.INT_TO_LONG,
+        new Info(Opcodes.INT_TO_LONG,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info INT_TO_FLOAT =
-        new Info(DalvOps.INT_TO_FLOAT,
+        new Info(Opcodes.INT_TO_FLOAT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info INT_TO_DOUBLE =
-        new Info(DalvOps.INT_TO_DOUBLE,
+        new Info(Opcodes.INT_TO_DOUBLE,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info LONG_TO_INT =
-        new Info(DalvOps.LONG_TO_INT,
+        new Info(Opcodes.LONG_TO_INT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info LONG_TO_FLOAT =
-        new Info(DalvOps.LONG_TO_FLOAT,
+        new Info(Opcodes.LONG_TO_FLOAT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info LONG_TO_DOUBLE =
-        new Info(DalvOps.LONG_TO_DOUBLE,
+        new Info(Opcodes.LONG_TO_DOUBLE,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info FLOAT_TO_INT =
-        new Info(DalvOps.FLOAT_TO_INT,
+        new Info(Opcodes.FLOAT_TO_INT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info FLOAT_TO_LONG =
-        new Info(DalvOps.FLOAT_TO_LONG,
+        new Info(Opcodes.FLOAT_TO_LONG,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info FLOAT_TO_DOUBLE =
-        new Info(DalvOps.FLOAT_TO_DOUBLE,
+        new Info(Opcodes.FLOAT_TO_DOUBLE,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info DOUBLE_TO_INT =
-        new Info(DalvOps.DOUBLE_TO_INT,
+        new Info(Opcodes.DOUBLE_TO_INT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info DOUBLE_TO_LONG =
-        new Info(DalvOps.DOUBLE_TO_LONG,
+        new Info(Opcodes.DOUBLE_TO_LONG,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info DOUBLE_TO_FLOAT =
-        new Info(DalvOps.DOUBLE_TO_FLOAT,
+        new Info(Opcodes.DOUBLE_TO_FLOAT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info INT_TO_BYTE =
-        new Info(DalvOps.INT_TO_BYTE,
+        new Info(Opcodes.INT_TO_BYTE,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info INT_TO_CHAR =
-        new Info(DalvOps.INT_TO_CHAR,
+        new Info(Opcodes.INT_TO_CHAR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info INT_TO_SHORT =
-        new Info(DalvOps.INT_TO_SHORT,
+        new Info(Opcodes.INT_TO_SHORT,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info ADD_INT =
-        new Info(DalvOps.ADD_INT,
+        new Info(Opcodes.ADD_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info SUB_INT =
-        new Info(DalvOps.SUB_INT,
+        new Info(Opcodes.SUB_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info MUL_INT =
-        new Info(DalvOps.MUL_INT,
+        new Info(Opcodes.MUL_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info DIV_INT =
-        new Info(DalvOps.DIV_INT,
+        new Info(Opcodes.DIV_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info REM_INT =
-        new Info(DalvOps.REM_INT,
+        new Info(Opcodes.REM_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info AND_INT =
-        new Info(DalvOps.AND_INT,
+        new Info(Opcodes.AND_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info OR_INT =
-        new Info(DalvOps.OR_INT,
+        new Info(Opcodes.OR_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info XOR_INT =
-        new Info(DalvOps.XOR_INT,
+        new Info(Opcodes.XOR_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info SHL_INT =
-        new Info(DalvOps.SHL_INT,
+        new Info(Opcodes.SHL_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info SHR_INT =
-        new Info(DalvOps.SHR_INT,
+        new Info(Opcodes.SHR_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info USHR_INT =
-        new Info(DalvOps.USHR_INT,
+        new Info(Opcodes.USHR_INT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info ADD_LONG =
-        new Info(DalvOps.ADD_LONG,
+        new Info(Opcodes.ADD_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info SUB_LONG =
-        new Info(DalvOps.SUB_LONG,
+        new Info(Opcodes.SUB_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info MUL_LONG =
-        new Info(DalvOps.MUL_LONG,
+        new Info(Opcodes.MUL_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info DIV_LONG =
-        new Info(DalvOps.DIV_LONG,
+        new Info(Opcodes.DIV_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info REM_LONG =
-        new Info(DalvOps.REM_LONG,
+        new Info(Opcodes.REM_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info AND_LONG =
-        new Info(DalvOps.AND_LONG,
+        new Info(Opcodes.AND_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info OR_LONG =
-        new Info(DalvOps.OR_LONG,
+        new Info(Opcodes.OR_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info XOR_LONG =
-        new Info(DalvOps.XOR_LONG,
+        new Info(Opcodes.XOR_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info SHL_LONG =
-        new Info(DalvOps.SHL_LONG,
+        new Info(Opcodes.SHL_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info SHR_LONG =
-        new Info(DalvOps.SHR_LONG,
+        new Info(Opcodes.SHR_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info USHR_LONG =
-        new Info(DalvOps.USHR_LONG,
+        new Info(Opcodes.USHR_LONG,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info ADD_FLOAT =
-        new Info(DalvOps.ADD_FLOAT,
+        new Info(Opcodes.ADD_FLOAT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info SUB_FLOAT =
-        new Info(DalvOps.SUB_FLOAT,
+        new Info(Opcodes.SUB_FLOAT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info MUL_FLOAT =
-        new Info(DalvOps.MUL_FLOAT,
+        new Info(Opcodes.MUL_FLOAT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info DIV_FLOAT =
-        new Info(DalvOps.DIV_FLOAT,
+        new Info(Opcodes.DIV_FLOAT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info REM_FLOAT =
-        new Info(DalvOps.REM_FLOAT,
+        new Info(Opcodes.REM_FLOAT,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info ADD_DOUBLE =
-        new Info(DalvOps.ADD_DOUBLE,
+        new Info(Opcodes.ADD_DOUBLE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info SUB_DOUBLE =
-        new Info(DalvOps.SUB_DOUBLE,
+        new Info(Opcodes.SUB_DOUBLE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info MUL_DOUBLE =
-        new Info(DalvOps.MUL_DOUBLE,
+        new Info(Opcodes.MUL_DOUBLE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info DIV_DOUBLE =
-        new Info(DalvOps.DIV_DOUBLE,
+        new Info(Opcodes.DIV_DOUBLE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info REM_DOUBLE =
-        new Info(DalvOps.REM_DOUBLE,
+        new Info(Opcodes.REM_DOUBLE,
             InstructionCodec.FORMAT_23X, null);
 
     public static final Info ADD_INT_2ADDR =
-        new Info(DalvOps.ADD_INT_2ADDR,
+        new Info(Opcodes.ADD_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info SUB_INT_2ADDR =
-        new Info(DalvOps.SUB_INT_2ADDR,
+        new Info(Opcodes.SUB_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info MUL_INT_2ADDR =
-        new Info(DalvOps.MUL_INT_2ADDR,
+        new Info(Opcodes.MUL_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info DIV_INT_2ADDR =
-        new Info(DalvOps.DIV_INT_2ADDR,
+        new Info(Opcodes.DIV_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info REM_INT_2ADDR =
-        new Info(DalvOps.REM_INT_2ADDR,
+        new Info(Opcodes.REM_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info AND_INT_2ADDR =
-        new Info(DalvOps.AND_INT_2ADDR,
+        new Info(Opcodes.AND_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info OR_INT_2ADDR =
-        new Info(DalvOps.OR_INT_2ADDR,
+        new Info(Opcodes.OR_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info XOR_INT_2ADDR =
-        new Info(DalvOps.XOR_INT_2ADDR,
+        new Info(Opcodes.XOR_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info SHL_INT_2ADDR =
-        new Info(DalvOps.SHL_INT_2ADDR,
+        new Info(Opcodes.SHL_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info SHR_INT_2ADDR =
-        new Info(DalvOps.SHR_INT_2ADDR,
+        new Info(Opcodes.SHR_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info USHR_INT_2ADDR =
-        new Info(DalvOps.USHR_INT_2ADDR,
+        new Info(Opcodes.USHR_INT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info ADD_LONG_2ADDR =
-        new Info(DalvOps.ADD_LONG_2ADDR,
+        new Info(Opcodes.ADD_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info SUB_LONG_2ADDR =
-        new Info(DalvOps.SUB_LONG_2ADDR,
+        new Info(Opcodes.SUB_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info MUL_LONG_2ADDR =
-        new Info(DalvOps.MUL_LONG_2ADDR,
+        new Info(Opcodes.MUL_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info DIV_LONG_2ADDR =
-        new Info(DalvOps.DIV_LONG_2ADDR,
+        new Info(Opcodes.DIV_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info REM_LONG_2ADDR =
-        new Info(DalvOps.REM_LONG_2ADDR,
+        new Info(Opcodes.REM_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info AND_LONG_2ADDR =
-        new Info(DalvOps.AND_LONG_2ADDR,
+        new Info(Opcodes.AND_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info OR_LONG_2ADDR =
-        new Info(DalvOps.OR_LONG_2ADDR,
+        new Info(Opcodes.OR_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info XOR_LONG_2ADDR =
-        new Info(DalvOps.XOR_LONG_2ADDR,
+        new Info(Opcodes.XOR_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info SHL_LONG_2ADDR =
-        new Info(DalvOps.SHL_LONG_2ADDR,
+        new Info(Opcodes.SHL_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info SHR_LONG_2ADDR =
-        new Info(DalvOps.SHR_LONG_2ADDR,
+        new Info(Opcodes.SHR_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info USHR_LONG_2ADDR =
-        new Info(DalvOps.USHR_LONG_2ADDR,
+        new Info(Opcodes.USHR_LONG_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info ADD_FLOAT_2ADDR =
-        new Info(DalvOps.ADD_FLOAT_2ADDR,
+        new Info(Opcodes.ADD_FLOAT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info SUB_FLOAT_2ADDR =
-        new Info(DalvOps.SUB_FLOAT_2ADDR,
+        new Info(Opcodes.SUB_FLOAT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info MUL_FLOAT_2ADDR =
-        new Info(DalvOps.MUL_FLOAT_2ADDR,
+        new Info(Opcodes.MUL_FLOAT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info DIV_FLOAT_2ADDR =
-        new Info(DalvOps.DIV_FLOAT_2ADDR,
+        new Info(Opcodes.DIV_FLOAT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info REM_FLOAT_2ADDR =
-        new Info(DalvOps.REM_FLOAT_2ADDR,
+        new Info(Opcodes.REM_FLOAT_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info ADD_DOUBLE_2ADDR =
-        new Info(DalvOps.ADD_DOUBLE_2ADDR,
+        new Info(Opcodes.ADD_DOUBLE_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info SUB_DOUBLE_2ADDR =
-        new Info(DalvOps.SUB_DOUBLE_2ADDR,
+        new Info(Opcodes.SUB_DOUBLE_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info MUL_DOUBLE_2ADDR =
-        new Info(DalvOps.MUL_DOUBLE_2ADDR,
+        new Info(Opcodes.MUL_DOUBLE_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info DIV_DOUBLE_2ADDR =
-        new Info(DalvOps.DIV_DOUBLE_2ADDR,
+        new Info(Opcodes.DIV_DOUBLE_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info REM_DOUBLE_2ADDR =
-        new Info(DalvOps.REM_DOUBLE_2ADDR,
+        new Info(Opcodes.REM_DOUBLE_2ADDR,
             InstructionCodec.FORMAT_12X, null);
 
     public static final Info ADD_INT_LIT16 =
-        new Info(DalvOps.ADD_INT_LIT16,
+        new Info(Opcodes.ADD_INT_LIT16,
             InstructionCodec.FORMAT_22S, null);
 
     public static final Info RSUB_INT =
-        new Info(DalvOps.RSUB_INT,
+        new Info(Opcodes.RSUB_INT,
             InstructionCodec.FORMAT_22S, null);
 
     public static final Info MUL_INT_LIT16 =
-        new Info(DalvOps.MUL_INT_LIT16,
+        new Info(Opcodes.MUL_INT_LIT16,
             InstructionCodec.FORMAT_22S, null);
 
     public static final Info DIV_INT_LIT16 =
-        new Info(DalvOps.DIV_INT_LIT16,
+        new Info(Opcodes.DIV_INT_LIT16,
             InstructionCodec.FORMAT_22S, null);
 
     public static final Info REM_INT_LIT16 =
-        new Info(DalvOps.REM_INT_LIT16,
+        new Info(Opcodes.REM_INT_LIT16,
             InstructionCodec.FORMAT_22S, null);
 
     public static final Info AND_INT_LIT16 =
-        new Info(DalvOps.AND_INT_LIT16,
+        new Info(Opcodes.AND_INT_LIT16,
             InstructionCodec.FORMAT_22S, null);
 
     public static final Info OR_INT_LIT16 =
-        new Info(DalvOps.OR_INT_LIT16,
+        new Info(Opcodes.OR_INT_LIT16,
             InstructionCodec.FORMAT_22S, null);
 
     public static final Info XOR_INT_LIT16 =
-        new Info(DalvOps.XOR_INT_LIT16,
+        new Info(Opcodes.XOR_INT_LIT16,
             InstructionCodec.FORMAT_22S, null);
 
     public static final Info ADD_INT_LIT8 =
-        new Info(DalvOps.ADD_INT_LIT8,
+        new Info(Opcodes.ADD_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info RSUB_INT_LIT8 =
-        new Info(DalvOps.RSUB_INT_LIT8,
+        new Info(Opcodes.RSUB_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info MUL_INT_LIT8 =
-        new Info(DalvOps.MUL_INT_LIT8,
+        new Info(Opcodes.MUL_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info DIV_INT_LIT8 =
-        new Info(DalvOps.DIV_INT_LIT8,
+        new Info(Opcodes.DIV_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info REM_INT_LIT8 =
-        new Info(DalvOps.REM_INT_LIT8,
+        new Info(Opcodes.REM_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info AND_INT_LIT8 =
-        new Info(DalvOps.AND_INT_LIT8,
+        new Info(Opcodes.AND_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info OR_INT_LIT8 =
-        new Info(DalvOps.OR_INT_LIT8,
+        new Info(Opcodes.OR_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info XOR_INT_LIT8 =
-        new Info(DalvOps.XOR_INT_LIT8,
+        new Info(Opcodes.XOR_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info SHL_INT_LIT8 =
-        new Info(DalvOps.SHL_INT_LIT8,
+        new Info(Opcodes.SHL_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info SHR_INT_LIT8 =
-        new Info(DalvOps.SHR_INT_LIT8,
+        new Info(Opcodes.SHR_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info USHR_INT_LIT8 =
-        new Info(DalvOps.USHR_INT_LIT8,
+        new Info(Opcodes.USHR_INT_LIT8,
             InstructionCodec.FORMAT_22B, null);
 
     public static final Info CONST_CLASS_JUMBO =
-        new Info(DalvOps.CONST_CLASS_JUMBO,
+        new Info(Opcodes.CONST_CLASS_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.TYPE_REF);
 
     public static final Info CHECK_CAST_JUMBO =
-        new Info(DalvOps.CHECK_CAST_JUMBO,
+        new Info(Opcodes.CHECK_CAST_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.TYPE_REF);
 
     public static final Info INSTANCE_OF_JUMBO =
-        new Info(DalvOps.INSTANCE_OF_JUMBO,
+        new Info(Opcodes.INSTANCE_OF_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.TYPE_REF);
 
     public static final Info NEW_INSTANCE_JUMBO =
-        new Info(DalvOps.NEW_INSTANCE_JUMBO,
+        new Info(Opcodes.NEW_INSTANCE_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.TYPE_REF);
 
     public static final Info NEW_ARRAY_JUMBO =
-        new Info(DalvOps.NEW_ARRAY_JUMBO,
+        new Info(Opcodes.NEW_ARRAY_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.TYPE_REF);
 
     public static final Info FILLED_NEW_ARRAY_JUMBO =
-        new Info(DalvOps.FILLED_NEW_ARRAY_JUMBO,
+        new Info(Opcodes.FILLED_NEW_ARRAY_JUMBO,
             InstructionCodec.FORMAT_5RC, IndexType.TYPE_REF);
 
     public static final Info IGET_JUMBO =
-        new Info(DalvOps.IGET_JUMBO,
+        new Info(Opcodes.IGET_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IGET_WIDE_JUMBO =
-        new Info(DalvOps.IGET_WIDE_JUMBO,
+        new Info(Opcodes.IGET_WIDE_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IGET_OBJECT_JUMBO =
-        new Info(DalvOps.IGET_OBJECT_JUMBO,
+        new Info(Opcodes.IGET_OBJECT_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IGET_BOOLEAN_JUMBO =
-        new Info(DalvOps.IGET_BOOLEAN_JUMBO,
+        new Info(Opcodes.IGET_BOOLEAN_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IGET_BYTE_JUMBO =
-        new Info(DalvOps.IGET_BYTE_JUMBO,
+        new Info(Opcodes.IGET_BYTE_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IGET_CHAR_JUMBO =
-        new Info(DalvOps.IGET_CHAR_JUMBO,
+        new Info(Opcodes.IGET_CHAR_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IGET_SHORT_JUMBO =
-        new Info(DalvOps.IGET_SHORT_JUMBO,
+        new Info(Opcodes.IGET_SHORT_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IPUT_JUMBO =
-        new Info(DalvOps.IPUT_JUMBO,
+        new Info(Opcodes.IPUT_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IPUT_WIDE_JUMBO =
-        new Info(DalvOps.IPUT_WIDE_JUMBO,
+        new Info(Opcodes.IPUT_WIDE_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IPUT_OBJECT_JUMBO =
-        new Info(DalvOps.IPUT_OBJECT_JUMBO,
+        new Info(Opcodes.IPUT_OBJECT_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IPUT_BOOLEAN_JUMBO =
-        new Info(DalvOps.IPUT_BOOLEAN_JUMBO,
+        new Info(Opcodes.IPUT_BOOLEAN_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IPUT_BYTE_JUMBO =
-        new Info(DalvOps.IPUT_BYTE_JUMBO,
+        new Info(Opcodes.IPUT_BYTE_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IPUT_CHAR_JUMBO =
-        new Info(DalvOps.IPUT_CHAR_JUMBO,
+        new Info(Opcodes.IPUT_CHAR_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info IPUT_SHORT_JUMBO =
-        new Info(DalvOps.IPUT_SHORT_JUMBO,
+        new Info(Opcodes.IPUT_SHORT_JUMBO,
             InstructionCodec.FORMAT_52C, IndexType.FIELD_REF);
 
     public static final Info SGET_JUMBO =
-        new Info(DalvOps.SGET_JUMBO,
+        new Info(Opcodes.SGET_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SGET_WIDE_JUMBO =
-        new Info(DalvOps.SGET_WIDE_JUMBO,
+        new Info(Opcodes.SGET_WIDE_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SGET_OBJECT_JUMBO =
-        new Info(DalvOps.SGET_OBJECT_JUMBO,
+        new Info(Opcodes.SGET_OBJECT_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SGET_BOOLEAN_JUMBO =
-        new Info(DalvOps.SGET_BOOLEAN_JUMBO,
+        new Info(Opcodes.SGET_BOOLEAN_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SGET_BYTE_JUMBO =
-        new Info(DalvOps.SGET_BYTE_JUMBO,
+        new Info(Opcodes.SGET_BYTE_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SGET_CHAR_JUMBO =
-        new Info(DalvOps.SGET_CHAR_JUMBO,
+        new Info(Opcodes.SGET_CHAR_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SGET_SHORT_JUMBO =
-        new Info(DalvOps.SGET_SHORT_JUMBO,
+        new Info(Opcodes.SGET_SHORT_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SPUT_JUMBO =
-        new Info(DalvOps.SPUT_JUMBO,
+        new Info(Opcodes.SPUT_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SPUT_WIDE_JUMBO =
-        new Info(DalvOps.SPUT_WIDE_JUMBO,
+        new Info(Opcodes.SPUT_WIDE_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SPUT_OBJECT_JUMBO =
-        new Info(DalvOps.SPUT_OBJECT_JUMBO,
+        new Info(Opcodes.SPUT_OBJECT_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SPUT_BOOLEAN_JUMBO =
-        new Info(DalvOps.SPUT_BOOLEAN_JUMBO,
+        new Info(Opcodes.SPUT_BOOLEAN_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SPUT_BYTE_JUMBO =
-        new Info(DalvOps.SPUT_BYTE_JUMBO,
+        new Info(Opcodes.SPUT_BYTE_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SPUT_CHAR_JUMBO =
-        new Info(DalvOps.SPUT_CHAR_JUMBO,
+        new Info(Opcodes.SPUT_CHAR_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info SPUT_SHORT_JUMBO =
-        new Info(DalvOps.SPUT_SHORT_JUMBO,
+        new Info(Opcodes.SPUT_SHORT_JUMBO,
             InstructionCodec.FORMAT_41C, IndexType.FIELD_REF);
 
     public static final Info INVOKE_VIRTUAL_JUMBO =
-        new Info(DalvOps.INVOKE_VIRTUAL_JUMBO,
+        new Info(Opcodes.INVOKE_VIRTUAL_JUMBO,
             InstructionCodec.FORMAT_5RC, IndexType.METHOD_REF);
 
     public static final Info INVOKE_SUPER_JUMBO =
-        new Info(DalvOps.INVOKE_SUPER_JUMBO,
+        new Info(Opcodes.INVOKE_SUPER_JUMBO,
             InstructionCodec.FORMAT_5RC, IndexType.METHOD_REF);
 
     public static final Info INVOKE_DIRECT_JUMBO =
-        new Info(DalvOps.INVOKE_DIRECT_JUMBO,
+        new Info(Opcodes.INVOKE_DIRECT_JUMBO,
             InstructionCodec.FORMAT_5RC, IndexType.METHOD_REF);
 
     public static final Info INVOKE_STATIC_JUMBO =
-        new Info(DalvOps.INVOKE_STATIC_JUMBO,
+        new Info(Opcodes.INVOKE_STATIC_JUMBO,
             InstructionCodec.FORMAT_5RC, IndexType.METHOD_REF);
 
     public static final Info INVOKE_INTERFACE_JUMBO =
-        new Info(DalvOps.INVOKE_INTERFACE_JUMBO,
+        new Info(Opcodes.INVOKE_INTERFACE_JUMBO,
             InstructionCodec.FORMAT_5RC, IndexType.METHOD_REF);
 
     // END(opcode-info-defs)
 
     // Static initialization.
     static {
-        INFO = new Info[DalvOps.MAX_VALUE - DalvOps.MIN_VALUE + 1];
+        INFO = new Info[Opcodes.MAX_VALUE - Opcodes.MIN_VALUE + 1];
 
         // BEGIN(opcode-info-init); GENERATED AUTOMATICALLY BY opcode-gen
         set(NOP);
@@ -1337,12 +1336,12 @@ public final class OpcodeInfo {
     /**
      * Gets the {@link @Info} for the given opcode value.
      *
-     * @param opcode {@code DalvOps.MIN_VALUE..DalvOps.MAX_VALUE;} the
+     * @param opcode {@code Opcodes.MIN_VALUE..Opcodes.MAX_VALUE;} the
      * opcode value
      * @return non-null; the associated opcode information instance
      */
     public static Info get(int opcode) {
-        int idx = opcode - DalvOps.MIN_VALUE;
+        int idx = opcode - Opcodes.MIN_VALUE;
 
         try {
             Info result = INFO[idx];
@@ -1370,7 +1369,7 @@ public final class OpcodeInfo {
      * @param opcode non-null; the opcode
      */
     private static void set(Info opcode) {
-        int idx = opcode.getOpcode() - DalvOps.MIN_VALUE;
+        int idx = opcode.getOpcode() - Opcodes.MIN_VALUE;
         INFO[idx] = opcode;
     }
 
diff --git a/dx/src/com/android/dx/dex/code/DalvOps.java b/dx/src/com/android/dx/io/Opcodes.java
index 2a83c700c..9dda7a326 100644
--- a/dx/src/com/android/dx/dex/code/DalvOps.java
+++ b/dx/src/com/android/dx/io/Opcodes.java
@@ -14,17 +14,20 @@
  * limitations under the License.
  */
 
-package com.android.dx.dex.code;
+package com.android.dx.io;
 
 /**
  * All the Dalvik opcode value constants. See the related spec
  * document for the meaning and instruction format of each opcode.
  */
-public final class DalvOps {
+public final class Opcodes {
     /** pseudo-opcode used for nonstandard format "instructions" */
     public static final int SPECIAL_FORMAT = -1;
 
-    /** pseudo-opcode used to indicate there is no next opcode */
+    /**
+     * pseudo-opcode used to indicate there is no next opcode; used
+     * in opcode chaining lists
+     */
     public static final int NO_NEXT = -1;
 
     /** minimum valid opcode value */
@@ -294,9 +297,25 @@ public final class DalvOps {
     // END(opcodes)
 
     /**
+     * special pseudo-opcode value for packed-switch data payload
+     * instructions
+     */
+    public static final int PACKED_SWITCH_PAYLOAD = 0x100;
+
+    /** special pseudo-opcode value for packed-switch data payload
+     * instructions
+     */
+    public static final int SPARSE_SWITCH_PAYLOAD = 0x200;
+
+    /** special pseudo-opcode value for fill-array-data data payload
+     * instructions
+     */
+    public static final int FILL_ARRAY_DATA_PAYLOAD = 0x300;
+
+    /**
      * This class is uninstantiable.
      */
-    private DalvOps() {
+    private Opcodes() {
         // This space intentionally left blank.
     }
 
diff --git a/opcode-gen/opcode-gen.awk b/opcode-gen/opcode-gen.awk
index 86e7cae59..e269abf39 100644
--- a/opcode-gen/opcode-gen.awk
+++ b/opcode-gen/opcode-gen.awk
@@ -80,7 +80,7 @@ emission == "first-opcodes" {
     for (i = 0; i <= MAX_OPCODE; i++) {
         if (isUnused(i) || isOptimized(i)) continue;
         if (isFirst[i] == "true") {
-            printf("    //     DalvOps.%s\n", constName[i]);
+            printf("    //     Opcodes.%s\n", constName[i]);
         }
     }
 }
@@ -95,8 +95,8 @@ emission == "dops" {
         nextOp = (nextOp == -1) ? "NO_NEXT" : constName[nextOp];
 
         printf("    public static final Dop %s =\n" \
-               "        new Dop(DalvOps.%s, DalvOps.%s,\n" \
-               "            DalvOps.%s, Form%s.THE_ONE, %s,\n" \
+               "        new Dop(Opcodes.%s, Opcodes.%s,\n" \
+               "            Opcodes.%s, Form%s.THE_ONE, %s,\n" \
                "            \"%s\");\n\n",
                constName[i], constName[i], family[i], nextOp, format[i],
                hasResult[i], name[i]);
@@ -119,7 +119,7 @@ emission == "opcode-info-defs" {
         }
 
         printf("    public static final Info %s =\n" \
-               "        new Info(DalvOps.%s,\n" \
+               "        new Info(Opcodes.%s,\n" \
                "            InstructionCodec.FORMAT_%s, %s);\n\n", \
                 constName[i], constName[i], toupper(format[i]), itype);
     }
diff --git a/opcode-gen/regen-all b/opcode-gen/regen-all
index 68bbd64d2..afe66242c 100755
--- a/opcode-gen/regen-all
+++ b/opcode-gen/regen-all
@@ -34,10 +34,10 @@ progdir=`pwd`
 # Be in the parent of the progdir when running the rest of the script.
 cd ".."
 
-${progdir}/opcode-gen dx/src/com/android/dx/dex/code/DalvOps.java
 ${progdir}/opcode-gen dx/src/com/android/dx/dex/code/Dops.java
 ${progdir}/opcode-gen dx/src/com/android/dx/dex/code/RopToDop.java
 ${progdir}/opcode-gen dx/src/com/android/dx/io/OpcodeInfo.java
+${progdir}/opcode-gen dx/src/com/android/dx/io/Opcodes.java
 ${progdir}/opcode-gen libdex/DexOpcodes.c
 ${progdir}/opcode-gen libdex/DexOpcodes.h
 ${progdir}/opcode-gen libdex/InstrUtils.c