Program: 88574
Project: 88574
Buggy source:
void emitInst(Inst inst){
  inst.apply(new InstSwitch(){
    public void caseReturnVoidInst(    ReturnVoidInst i){
      emit("String_Node_Str");
    }
    public void caseReturnInst(    ReturnInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t.toString());
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
        }
        public void caseIntType(        IntType t){
          emit("String_Node_Str");
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str");
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str");
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str");
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str");
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str");
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str");
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str");
        }
      }
);
    }
    public void caseNopInst(    NopInst i){
      emit("String_Node_Str");
    }
    public void caseEnterMonitorInst(    EnterMonitorInst i){
      emit("String_Node_Str");
    }
    public void casePopInst(    PopInst i){
      if (i.getWordCount() == 2) {
        emit("String_Node_Str");
      }
 else       emit("String_Node_Str");
    }
    public void caseExitMonitorInst(    ExitMonitorInst i){
      emit("String_Node_Str");
    }
    public void caseGotoInst(    GotoInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void casePushInst(    PushInst i){
      if (i.getConstant() instanceof IntConstant) {
        IntConstant v=(IntConstant)(i.getConstant());
        if (v.value == -1)         emit("String_Node_Str");
 else         if (v.value >= 0 && v.value <= 5)         emit("String_Node_Str" + v.value);
 else         if (v.value >= Byte.MIN_VALUE && v.value <= Byte.MAX_VALUE)         emit("String_Node_Str" + v.value);
 else         if (v.value >= Short.MIN_VALUE && v.value <= Short.MAX_VALUE)         emit("String_Node_Str" + v.value);
 else         emit("String_Node_Str" + v.toString());
      }
 else       if (i.getConstant() instanceof StringConstant) {
        emit("String_Node_Str" + i.getConstant().toString());
      }
 else       if (i.getConstant() instanceof DoubleConstant) {
        DoubleConstant v=(DoubleConstant)(i.getConstant());
        if ((v.value == 0) && ((1.0 / v.value) > 0.0))         emit("String_Node_Str");
 else         if (v.value == 1)         emit("String_Node_Str");
 else {
          String s=v.toString();
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          emit("String_Node_Str" + s);
        }
      }
 else       if (i.getConstant() instanceof FloatConstant) {
        FloatConstant v=(FloatConstant)(i.getConstant());
        if ((v.value == 0) && ((1.0f / v.value) > 1.0f))         emit("String_Node_Str");
 else         if (v.value == 1)         emit("String_Node_Str");
 else         if (v.value == 2)         emit("String_Node_Str");
 else {
          String s=v.toString();
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          emit("String_Node_Str" + s);
        }
      }
 else       if (i.getConstant() instanceof LongConstant) {
        LongConstant v=(LongConstant)(i.getConstant());
        if (v.value == 0)         emit("String_Node_Str");
 else         if (v.value == 1)         emit("String_Node_Str");
 else         emit("String_Node_Str" + v.toString());
      }
 else       if (i.getConstant() instanceof NullConstant)       emit("String_Node_Str");
 else       throw new RuntimeException("String_Node_Str");
    }
    public void caseIdentityInst(    IdentityInst i){
      if (i.getRightOp() instanceof CaughtExceptionRef && i.getLeftOp() instanceof Local) {
        int slot=((Integer)localToSlot.get(i.getLeftOp())).intValue();
        if (slot >= 0 && slot <= 3)         emit("String_Node_Str" + slot);
 else         emit("String_Node_Str" + slot);
      }
    }
    public void caseStoreInst(    StoreInst i){
      final int slot=((Integer)localToSlot.get(i.getLocal())).intValue();
      i.getOpType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseDoubleType(        DoubleType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseFloatType(        FloatType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseIntType(        IntType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseByteType(        ByteType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseShortType(        ShortType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseCharType(        CharType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseBooleanType(        BooleanType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseLongType(        LongType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseRefType(        RefType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseStmtAddressType(        StmtAddressType t){
          isNextGotoAJsr=true;
          returnAddressSlot=slot;
        }
        public void caseNullType(        NullType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t);
        }
      }
);
    }
    public void caseLoadInst(    LoadInst i){
      final int slot=((Integer)localToSlot.get(i.getLocal())).intValue();
      i.getOpType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t);
        }
        public void caseDoubleType(        DoubleType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseFloatType(        FloatType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseIntType(        IntType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseByteType(        ByteType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseShortType(        ShortType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseCharType(        CharType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseBooleanType(        BooleanType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseLongType(        LongType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseRefType(        RefType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseNullType(        NullType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
      }
);
    }
    public void caseArrayWriteInst(    ArrayWriteInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str");
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
        }
        public void caseIntType(        IntType t){
          emit("String_Node_Str");
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str");
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str");
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str");
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str");
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t);
        }
      }
);
    }
    public void caseArrayReadInst(    ArrayReadInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType ty){
          emit("String_Node_Str");
        }
        public void caseBooleanType(        BooleanType ty){
          emit("String_Node_Str");
        }
        public void caseByteType(        ByteType ty){
          emit("String_Node_Str");
        }
        public void caseCharType(        CharType ty){
          emit("String_Node_Str");
        }
        public void defaultCase(        Type ty){
          throw new RuntimeException("String_Node_Str");
        }
        public void caseDoubleType(        DoubleType ty){
          emit("String_Node_Str");
        }
        public void caseFloatType(        FloatType ty){
          emit("String_Node_Str");
        }
        public void caseIntType(        IntType ty){
          emit("String_Node_Str");
        }
        public void caseLongType(        LongType ty){
          emit("String_Node_Str");
        }
        public void caseNullType(        NullType ty){
          emit("String_Node_Str");
        }
        public void caseRefType(        RefType ty){
          emit("String_Node_Str");
        }
        public void caseShortType(        ShortType ty){
          emit("String_Node_Str");
        }
      }
);
    }
    public void caseIfNullInst(    IfNullInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfNonNullInst(    IfNonNullInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfEqInst(    IfEqInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfNeInst(    IfNeInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfGtInst(    IfGtInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfGeInst(    IfGeInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfLtInst(    IfLtInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfLeInst(    IfLeInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfCmpEqInst(    final IfCmpEqInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpNeInst(    final IfCmpNeInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpGtInst(    final IfCmpGtInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpGeInst(    final IfCmpGeInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpLtInst(    final IfCmpLtInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpLeInst(    final IfCmpLeInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseStaticGetInst(    StaticGetInst i){
      SootField field=i.getField();
      emit("String_Node_Str" + slashify(field.getDeclaringClass().getName()) + "String_Node_Str"+ field.getName()+ "String_Node_Str"+ jasminDescriptorOf(field.getType()));
    }
    public void caseStaticPutInst(    StaticPutInst i){
      emit("String_Node_Str" + slashify(i.getField().getDeclaringClass().getName()) + "String_Node_Str"+ i.getField().getName()+ "String_Node_Str"+ jasminDescriptorOf(i.getField().getType()));
    }
    public void caseFieldGetInst(    FieldGetInst i){
      emit("String_Node_Str" + slashify(i.getField().getDeclaringClass().getName()) + "String_Node_Str"+ i.getField().getName()+ "String_Node_Str"+ jasminDescriptorOf(i.getField().getType()));
    }
    public void caseFieldPutInst(    FieldPutInst i){
      emit("String_Node_Str" + slashify(i.getField().getDeclaringClass().getName()) + "String_Node_Str"+ i.getField().getName()+ "String_Node_Str"+ jasminDescriptorOf(i.getField().getType()));
    }
    public void caseInstanceCastInst(    InstanceCastInst i){
      Type castType=i.getCastType();
      if (castType instanceof RefType)       emit("String_Node_Str" + slashify(castType.toString()));
 else       if (castType instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(castType));
    }
    public void caseInstanceOfInst(    InstanceOfInst i){
      Type checkType=i.getCheckType();
      if (checkType instanceof RefType)       emit("String_Node_Str" + slashify(checkType.toString()));
 else       if (checkType instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(checkType));
    }
    public void caseNewInst(    NewInst i){
      emit("String_Node_Str" + slashify(i.getBaseType().toString()));
    }
    public void casePrimitiveCastInst(    PrimitiveCastInst i){
      emit(i.toString());
    }
    public void caseStaticInvokeInst(    StaticInvokeInst i){
      SootMethodRef m=i.getMethodRef();
      emit("String_Node_Str" + slashify(m.declaringClass().getName()) + "String_Node_Str"+ m.name()+ jasminDescriptorOf(m));
    }
    public void caseVirtualInvokeInst(    VirtualInvokeInst i){
      SootMethodRef m=i.getMethodRef();
      emit("String_Node_Str" + slashify(m.declaringClass().getName()) + "String_Node_Str"+ m.name()+ jasminDescriptorOf(m));
    }
    public void caseInterfaceInvokeInst(    InterfaceInvokeInst i){
      SootMethodRef m=i.getMethodRef();
      emit("String_Node_Str" + slashify(m.declaringClass().getName()) + "String_Node_Str"+ m.name()+ jasminDescriptorOf(m)+ "String_Node_Str"+ (argCountOf(m) + 1));
    }
    public void caseSpecialInvokeInst(    SpecialInvokeInst i){
      SootMethodRef m=i.getMethodRef();
      emit("String_Node_Str" + slashify(m.declaringClass().getName()) + "String_Node_Str"+ m.name()+ jasminDescriptorOf(m));
    }
    public void caseThrowInst(    ThrowInst i){
      emit("String_Node_Str");
    }
    public void caseCmpInst(    CmpInst i){
      emit("String_Node_Str");
    }
    public void caseCmplInst(    CmplInst i){
      if (i.getOpType().equals(FloatType.v()))       emit("String_Node_Str");
 else       emit("String_Node_Str");
    }
    public void caseCmpgInst(    CmpgInst i){
      if (i.getOpType().equals(FloatType.v()))       emit("String_Node_Str");
 else       emit("String_Node_Str");
    }
    private void emitOpTypeInst(    final String s,    final OpTypeArgInst i){
      i.getOpType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str" + s);
        }
        public void caseIntType(        IntType t){
          handleIntCase();
        }
        public void caseBooleanType(        BooleanType t){
          handleIntCase();
        }
        public void caseShortType(        ShortType t){
          handleIntCase();
        }
        public void caseCharType(        CharType t){
          handleIntCase();
        }
        public void caseByteType(        ByteType t){
          handleIntCase();
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str" + s);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str" + s);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str" + s);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseAddInst(    AddInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseDivInst(    DivInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseSubInst(    SubInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseMulInst(    MulInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseRemInst(    RemInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseShlInst(    ShlInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseAndInst(    AndInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseOrInst(    OrInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseXorInst(    XorInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseShrInst(    ShrInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseUshrInst(    UshrInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseIncInst(    IncInst i){
      if (((ValueBox)i.getUseBoxes().get(0)).getValue() != ((ValueBox)i.getDefBoxes().get(0)).getValue())       throw new RuntimeException("String_Node_Str");
      emit("String_Node_Str" + ((Integer)localToSlot.get(i.getLocal())) + "String_Node_Str"+ i.getConstant());
    }
    public void caseArrayLengthInst(    ArrayLengthInst i){
      emit("String_Node_Str");
    }
    public void caseNegInst(    NegInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseNewArrayInst(    NewArrayInst i){
      if (i.getBaseType() instanceof RefType)       emit("String_Node_Str" + slashify(i.getBaseType().toString()));
 else       if (i.getBaseType() instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(i.getBaseType()));
 else       emit("String_Node_Str" + i.getBaseType().toString());
    }
    public void caseNewMultiArrayInst(    NewMultiArrayInst i){
      emit("String_Node_Str" + jasminDescriptorOf(i.getBaseType()) + "String_Node_Str"+ i.getDimensionCount());
    }
    public void caseLookupSwitchInst(    LookupSwitchInst i){
      emit("String_Node_Str");
      List lookupValues=i.getLookupValues();
      List targets=i.getTargets();
      for (int j=0; j < lookupValues.size(); j++)       emit("String_Node_Str" + lookupValues.get(j) + "String_Node_Str"+ unitToLabel.get(targets.get(j)));
      emit("String_Node_Str" + unitToLabel.get(i.getDefaultTarget()));
    }
    public void caseTableSwitchInst(    TableSwitchInst i){
      emit("String_Node_Str" + i.getLowIndex() + "String_Node_Str"+ i.getHighIndex());
      List targets=i.getTargets();
      for (int j=0; j < targets.size(); j++)       emit("String_Node_Str" + unitToLabel.get(targets.get(j)));
      emit("String_Node_Str" + unitToLabel.get(i.getDefaultTarget()));
    }
    private boolean isDwordType(    Type t){
      return t instanceof LongType || t instanceof DoubleType || t instanceof DoubleWordType;
    }
    public void caseDup1Inst(    Dup1Inst i){
      Type firstOpType=i.getOp1Type();
      if (isDwordType(firstOpType))       emit("String_Node_Str");
 else       emit("String_Node_Str");
    }
    public void caseDup2Inst(    Dup2Inst i){
      Type firstOpType=i.getOp1Type();
      Type secondOpType=i.getOp2Type();
      if (isDwordType(firstOpType)) {
        emit("String_Node_Str");
        if (isDwordType(secondOpType)) {
          emit("String_Node_Str");
        }
 else         emit("String_Node_Str");
      }
 else       if (isDwordType(secondOpType)) {
        if (isDwordType(firstOpType)) {
          emit("String_Node_Str");
        }
 else         emit("String_Node_Str");
        emit("String_Node_Str");
      }
 else {
        G.v().out.println("String_Node_Str");
        emit("String_Node_Str");
      }
    }
    public void caseDup1_x1Inst(    Dup1_x1Inst i){
      Type opType=i.getOp1Type();
      Type underType=i.getUnder1Type();
      if (isDwordType(opType)) {
        if (isDwordType(underType)) {
          emit("String_Node_Str");
        }
 else         emit("String_Node_Str");
      }
 else {
        if (isDwordType(underType))         emit("String_Node_Str");
 else         emit("String_Node_Str");
      }
    }
    public void caseDup1_x2Inst(    Dup1_x2Inst i){
      Type opType=i.getOp1Type();
      Type under1Type=i.getUnder1Type();
      Type under2Type=i.getUnder2Type();
      if (isDwordType(opType)) {
        if (!isDwordType(under1Type) && !isDwordType(under2Type))         emit("String_Node_Str");
 else         throw new RuntimeException("String_Node_Str");
      }
 else {
        if (isDwordType(under1Type) || isDwordType(under2Type))         throw new RuntimeException("String_Node_Str");
      }
      emit("String_Node_Str");
    }
    public void caseDup2_x1Inst(    Dup2_x1Inst i){
      Type op1Type=i.getOp1Type();
      Type op2Type=i.getOp2Type();
      Type under1Type=i.getUnder1Type();
      if (isDwordType(under1Type)) {
        if (!isDwordType(op1Type) && !isDwordType(op2Type))         throw new RuntimeException("String_Node_Str");
 else         emit("String_Node_Str");
      }
 else {
        if (isDwordType(op1Type) || isDwordType(op2Type))         throw new RuntimeException("String_Node_Str");
      }
      emit("String_Node_Str");
    }
    public void caseDup2_x2Inst(    Dup2_x2Inst i){
      Type op1Type=i.getOp1Type();
      Type op2Type=i.getOp2Type();
      Type under1Type=i.getUnder1Type();
      Type under2Type=i.getUnder2Type();
      if (isDwordType(op1Type) || isDwordType(op2Type) || isDwordType(under1Type)|| isDwordType(under1Type))       throw new RuntimeException("String_Node_Str");
      emit("String_Node_Str");
    }
    public void caseSwapInst(    SwapInst i){
      emit("String_Node_Str");
    }
  }
);
}

Fixed version (ground truth):
void emitInst(Inst inst){
  inst.apply(new InstSwitch(){
    public void caseReturnVoidInst(    ReturnVoidInst i){
      emit("String_Node_Str");
    }
    public void caseReturnInst(    ReturnInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t.toString());
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
        }
        public void caseIntType(        IntType t){
          emit("String_Node_Str");
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str");
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str");
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str");
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str");
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str");
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str");
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str");
        }
      }
);
    }
    public void caseNopInst(    NopInst i){
      emit("String_Node_Str");
    }
    public void caseEnterMonitorInst(    EnterMonitorInst i){
      emit("String_Node_Str");
    }
    public void casePopInst(    PopInst i){
      if (i.getWordCount() == 2) {
        emit("String_Node_Str");
      }
 else       emit("String_Node_Str");
    }
    public void caseExitMonitorInst(    ExitMonitorInst i){
      emit("String_Node_Str");
    }
    public void caseGotoInst(    GotoInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void casePushInst(    PushInst i){
      if (i.getConstant() instanceof IntConstant) {
        IntConstant v=(IntConstant)(i.getConstant());
        if (v.value == -1)         emit("String_Node_Str");
 else         if (v.value >= 0 && v.value <= 5)         emit("String_Node_Str" + v.value);
 else         if (v.value >= Byte.MIN_VALUE && v.value <= Byte.MAX_VALUE)         emit("String_Node_Str" + v.value);
 else         if (v.value >= Short.MIN_VALUE && v.value <= Short.MAX_VALUE)         emit("String_Node_Str" + v.value);
 else         emit("String_Node_Str" + v.toString());
      }
 else       if (i.getConstant() instanceof StringConstant) {
        emit("String_Node_Str" + i.getConstant().toString());
      }
 else       if (i.getConstant() instanceof DoubleConstant) {
        DoubleConstant v=(DoubleConstant)(i.getConstant());
        if ((v.value == 0) && ((1.0 / v.value) > 0.0))         emit("String_Node_Str");
 else         if (v.value == 1)         emit("String_Node_Str");
 else {
          String s=v.toString();
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          emit("String_Node_Str" + s);
        }
      }
 else       if (i.getConstant() instanceof FloatConstant) {
        FloatConstant v=(FloatConstant)(i.getConstant());
        if ((v.value == 0) && ((1.0f / v.value) > 1.0f))         emit("String_Node_Str");
 else         if (v.value == 1)         emit("String_Node_Str");
 else         if (v.value == 2)         emit("String_Node_Str");
 else {
          String s=v.toString();
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          if (s.equals("String_Node_Str"))           s="String_Node_Str";
          emit("String_Node_Str" + s);
        }
      }
 else       if (i.getConstant() instanceof LongConstant) {
        LongConstant v=(LongConstant)(i.getConstant());
        if (v.value == 0)         emit("String_Node_Str");
 else         if (v.value == 1)         emit("String_Node_Str");
 else         emit("String_Node_Str" + v.toString());
      }
 else       if (i.getConstant() instanceof NullConstant)       emit("String_Node_Str");
 else       throw new RuntimeException("String_Node_Str");
    }
    public void caseIdentityInst(    IdentityInst i){
      if (i.getRightOp() instanceof CaughtExceptionRef && i.getLeftOp() instanceof Local) {
        int slot=((Integer)localToSlot.get(i.getLeftOp())).intValue();
        if (slot >= 0 && slot <= 3)         emit("String_Node_Str" + slot);
 else         emit("String_Node_Str" + slot);
      }
    }
    public void caseStoreInst(    StoreInst i){
      final int slot=((Integer)localToSlot.get(i.getLocal())).intValue();
      i.getOpType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseDoubleType(        DoubleType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseFloatType(        FloatType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseIntType(        IntType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseByteType(        ByteType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseShortType(        ShortType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseCharType(        CharType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseBooleanType(        BooleanType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseLongType(        LongType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseRefType(        RefType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseStmtAddressType(        StmtAddressType t){
          isNextGotoAJsr=true;
          returnAddressSlot=slot;
        }
        public void caseNullType(        NullType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t);
        }
      }
);
    }
    public void caseLoadInst(    LoadInst i){
      final int slot=((Integer)localToSlot.get(i.getLocal())).intValue();
      i.getOpType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t);
        }
        public void caseDoubleType(        DoubleType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseFloatType(        FloatType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseIntType(        IntType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseByteType(        ByteType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseShortType(        ShortType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseCharType(        CharType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseBooleanType(        BooleanType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseLongType(        LongType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseRefType(        RefType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
        public void caseNullType(        NullType t){
          if (slot >= 0 && slot <= 3)           emit("String_Node_Str" + slot);
 else           emit("String_Node_Str" + slot);
        }
      }
);
    }
    public void caseArrayWriteInst(    ArrayWriteInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str");
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
        }
        public void caseIntType(        IntType t){
          emit("String_Node_Str");
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str");
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str");
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str");
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str");
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t);
        }
      }
);
    }
    public void caseArrayReadInst(    ArrayReadInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType ty){
          emit("String_Node_Str");
        }
        public void caseBooleanType(        BooleanType ty){
          emit("String_Node_Str");
        }
        public void caseByteType(        ByteType ty){
          emit("String_Node_Str");
        }
        public void caseCharType(        CharType ty){
          emit("String_Node_Str");
        }
        public void defaultCase(        Type ty){
          throw new RuntimeException("String_Node_Str");
        }
        public void caseDoubleType(        DoubleType ty){
          emit("String_Node_Str");
        }
        public void caseFloatType(        FloatType ty){
          emit("String_Node_Str");
        }
        public void caseIntType(        IntType ty){
          emit("String_Node_Str");
        }
        public void caseLongType(        LongType ty){
          emit("String_Node_Str");
        }
        public void caseNullType(        NullType ty){
          emit("String_Node_Str");
        }
        public void caseRefType(        RefType ty){
          emit("String_Node_Str");
        }
        public void caseShortType(        ShortType ty){
          emit("String_Node_Str");
        }
      }
);
    }
    public void caseIfNullInst(    IfNullInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfNonNullInst(    IfNonNullInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfEqInst(    IfEqInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfNeInst(    IfNeInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfGtInst(    IfGtInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfGeInst(    IfGeInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfLtInst(    IfLtInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfLeInst(    IfLeInst i){
      emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
    }
    public void caseIfCmpEqInst(    final IfCmpEqInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpNeInst(    final IfCmpNeInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpGtInst(    final IfCmpGtInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpGeInst(    final IfCmpGeInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpLtInst(    final IfCmpLtInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseIfCmpLeInst(    final IfCmpLeInst i){
      i.getOpType().apply(new TypeSwitch(){
        public void caseIntType(        IntType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseBooleanType(        BooleanType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseShortType(        ShortType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseCharType(        CharType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseByteType(        ByteType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str");
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseArrayType(        ArrayType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseRefType(        RefType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void caseNullType(        NullType t){
          emit("String_Node_Str" + unitToLabel.get(i.getTarget()));
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseStaticGetInst(    StaticGetInst i){
      SootFieldRef field=i.getFieldRef();
      emit("String_Node_Str" + slashify(field.declaringClass().getName()) + "String_Node_Str"+ field.name()+ "String_Node_Str"+ jasminDescriptorOf(field.type()));
    }
    public void caseStaticPutInst(    StaticPutInst i){
      emit("String_Node_Str" + slashify(i.getFieldRef().declaringClass().getName()) + "String_Node_Str"+ i.getFieldRef().name()+ "String_Node_Str"+ jasminDescriptorOf(i.getFieldRef().type()));
    }
    public void caseFieldGetInst(    FieldGetInst i){
      emit("String_Node_Str" + slashify(i.getFieldRef().declaringClass().getName()) + "String_Node_Str"+ i.getFieldRef().name()+ "String_Node_Str"+ jasminDescriptorOf(i.getFieldRef().type()));
    }
    public void caseFieldPutInst(    FieldPutInst i){
      emit("String_Node_Str" + slashify(i.getFieldRef().declaringClass().getName()) + "String_Node_Str"+ i.getFieldRef().name()+ "String_Node_Str"+ jasminDescriptorOf(i.getFieldRef().type()));
    }
    public void caseInstanceCastInst(    InstanceCastInst i){
      Type castType=i.getCastType();
      if (castType instanceof RefType)       emit("String_Node_Str" + slashify(castType.toString()));
 else       if (castType instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(castType));
    }
    public void caseInstanceOfInst(    InstanceOfInst i){
      Type checkType=i.getCheckType();
      if (checkType instanceof RefType)       emit("String_Node_Str" + slashify(checkType.toString()));
 else       if (checkType instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(checkType));
    }
    public void caseNewInst(    NewInst i){
      emit("String_Node_Str" + slashify(i.getBaseType().toString()));
    }
    public void casePrimitiveCastInst(    PrimitiveCastInst i){
      emit(i.toString());
    }
    public void caseStaticInvokeInst(    StaticInvokeInst i){
      SootMethodRef m=i.getMethodRef();
      emit("String_Node_Str" + slashify(m.declaringClass().getName()) + "String_Node_Str"+ m.name()+ jasminDescriptorOf(m));
    }
    public void caseVirtualInvokeInst(    VirtualInvokeInst i){
      SootMethodRef m=i.getMethodRef();
      emit("String_Node_Str" + slashify(m.declaringClass().getName()) + "String_Node_Str"+ m.name()+ jasminDescriptorOf(m));
    }
    public void caseInterfaceInvokeInst(    InterfaceInvokeInst i){
      SootMethodRef m=i.getMethodRef();
      emit("String_Node_Str" + slashify(m.declaringClass().getName()) + "String_Node_Str"+ m.name()+ jasminDescriptorOf(m)+ "String_Node_Str"+ (argCountOf(m) + 1));
    }
    public void caseSpecialInvokeInst(    SpecialInvokeInst i){
      SootMethodRef m=i.getMethodRef();
      emit("String_Node_Str" + slashify(m.declaringClass().getName()) + "String_Node_Str"+ m.name()+ jasminDescriptorOf(m));
    }
    public void caseThrowInst(    ThrowInst i){
      emit("String_Node_Str");
    }
    public void caseCmpInst(    CmpInst i){
      emit("String_Node_Str");
    }
    public void caseCmplInst(    CmplInst i){
      if (i.getOpType().equals(FloatType.v()))       emit("String_Node_Str");
 else       emit("String_Node_Str");
    }
    public void caseCmpgInst(    CmpgInst i){
      if (i.getOpType().equals(FloatType.v()))       emit("String_Node_Str");
 else       emit("String_Node_Str");
    }
    private void emitOpTypeInst(    final String s,    final OpTypeArgInst i){
      i.getOpType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str" + s);
        }
        public void caseIntType(        IntType t){
          handleIntCase();
        }
        public void caseBooleanType(        BooleanType t){
          handleIntCase();
        }
        public void caseShortType(        ShortType t){
          handleIntCase();
        }
        public void caseCharType(        CharType t){
          handleIntCase();
        }
        public void caseByteType(        ByteType t){
          handleIntCase();
        }
        public void caseLongType(        LongType t){
          emit("String_Node_Str" + s);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str" + s);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str" + s);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseAddInst(    AddInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseDivInst(    DivInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseSubInst(    SubInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseMulInst(    MulInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseRemInst(    RemInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseShlInst(    ShlInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseAndInst(    AndInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseOrInst(    OrInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseXorInst(    XorInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseShrInst(    ShrInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseUshrInst(    UshrInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseIncInst(    IncInst i){
      if (((ValueBox)i.getUseBoxes().get(0)).getValue() != ((ValueBox)i.getDefBoxes().get(0)).getValue())       throw new RuntimeException("String_Node_Str");
      emit("String_Node_Str" + ((Integer)localToSlot.get(i.getLocal())) + "String_Node_Str"+ i.getConstant());
    }
    public void caseArrayLengthInst(    ArrayLengthInst i){
      emit("String_Node_Str");
    }
    public void caseNegInst(    NegInst i){
      emitOpTypeInst("String_Node_Str",i);
    }
    public void caseNewArrayInst(    NewArrayInst i){
      if (i.getBaseType() instanceof RefType)       emit("String_Node_Str" + slashify(i.getBaseType().toString()));
 else       if (i.getBaseType() instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(i.getBaseType()));
 else       emit("String_Node_Str" + i.getBaseType().toString());
    }
    public void caseNewMultiArrayInst(    NewMultiArrayInst i){
      emit("String_Node_Str" + jasminDescriptorOf(i.getBaseType()) + "String_Node_Str"+ i.getDimensionCount());
    }
    public void caseLookupSwitchInst(    LookupSwitchInst i){
      emit("String_Node_Str");
      List lookupValues=i.getLookupValues();
      List targets=i.getTargets();
      for (int j=0; j < lookupValues.size(); j++)       emit("String_Node_Str" + lookupValues.get(j) + "String_Node_Str"+ unitToLabel.get(targets.get(j)));
      emit("String_Node_Str" + unitToLabel.get(i.getDefaultTarget()));
    }
    public void caseTableSwitchInst(    TableSwitchInst i){
      emit("String_Node_Str" + i.getLowIndex() + "String_Node_Str"+ i.getHighIndex());
      List targets=i.getTargets();
      for (int j=0; j < targets.size(); j++)       emit("String_Node_Str" + unitToLabel.get(targets.get(j)));
      emit("String_Node_Str" + unitToLabel.get(i.getDefaultTarget()));
    }
    private boolean isDwordType(    Type t){
      return t instanceof LongType || t instanceof DoubleType || t instanceof DoubleWordType;
    }
    public void caseDup1Inst(    Dup1Inst i){
      Type firstOpType=i.getOp1Type();
      if (isDwordType(firstOpType))       emit("String_Node_Str");
 else       emit("String_Node_Str");
    }
    public void caseDup2Inst(    Dup2Inst i){
      Type firstOpType=i.getOp1Type();
      Type secondOpType=i.getOp2Type();
      if (isDwordType(firstOpType)) {
        emit("String_Node_Str");
        if (isDwordType(secondOpType)) {
          emit("String_Node_Str");
        }
 else         emit("String_Node_Str");
      }
 else       if (isDwordType(secondOpType)) {
        if (isDwordType(firstOpType)) {
          emit("String_Node_Str");
        }
 else         emit("String_Node_Str");
        emit("String_Node_Str");
      }
 else {
        G.v().out.println("String_Node_Str");
        emit("String_Node_Str");
      }
    }
    public void caseDup1_x1Inst(    Dup1_x1Inst i){
      Type opType=i.getOp1Type();
      Type underType=i.getUnder1Type();
      if (isDwordType(opType)) {
        if (isDwordType(underType)) {
          emit("String_Node_Str");
        }
 else         emit("String_Node_Str");
      }
 else {
        if (isDwordType(underType))         emit("String_Node_Str");
 else         emit("String_Node_Str");
      }
    }
    public void caseDup1_x2Inst(    Dup1_x2Inst i){
      Type opType=i.getOp1Type();
      Type under1Type=i.getUnder1Type();
      Type under2Type=i.getUnder2Type();
      if (isDwordType(opType)) {
        if (!isDwordType(under1Type) && !isDwordType(under2Type))         emit("String_Node_Str");
 else         throw new RuntimeException("String_Node_Str");
      }
 else {
        if (isDwordType(under1Type) || isDwordType(under2Type))         throw new RuntimeException("String_Node_Str");
      }
      emit("String_Node_Str");
    }
    public void caseDup2_x1Inst(    Dup2_x1Inst i){
      Type op1Type=i.getOp1Type();
      Type op2Type=i.getOp2Type();
      Type under1Type=i.getUnder1Type();
      if (isDwordType(under1Type)) {
        if (!isDwordType(op1Type) && !isDwordType(op2Type))         throw new RuntimeException("String_Node_Str");
 else         emit("String_Node_Str");
      }
 else {
        if (isDwordType(op1Type) || isDwordType(op2Type))         throw new RuntimeException("String_Node_Str");
      }
      emit("String_Node_Str");
    }
    public void caseDup2_x2Inst(    Dup2_x2Inst i){
      Type op1Type=i.getOp1Type();
      Type op2Type=i.getOp2Type();
      Type under1Type=i.getUnder1Type();
      Type under2Type=i.getUnder2Type();
      if (isDwordType(op1Type) || isDwordType(op2Type) || isDwordType(under1Type)|| isDwordType(under1Type))       throw new RuntimeException("String_Node_Str");
      emit("String_Node_Str");
    }
    public void caseSwapInst(    SwapInst i){
      emit("String_Node_Str");
    }
  }
);
}