Program: 88642
Project: 88642
Buggy source:
void emitValue(Value value){
  value.apply(new AbstractGrimpValueSwitch(){
    public void caseAddExpr(    AddExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseAndExpr(    AndExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseArrayRef(    ArrayRef v){
      emitValue(v.getBase());
      emitValue(v.getIndex());
      v.getType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType ty){
          emit("String_Node_Str",-1);
        }
        public void caseBooleanType(        BooleanType ty){
          emit("String_Node_Str",-1);
        }
        public void caseByteType(        ByteType ty){
          emit("String_Node_Str",-1);
        }
        public void caseCharType(        CharType ty){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type ty){
          throw new RuntimeException("String_Node_Str");
        }
        public void caseDoubleType(        DoubleType ty){
          emit("String_Node_Str",0);
        }
        public void caseFloatType(        FloatType ty){
          emit("String_Node_Str",-1);
        }
        public void caseIntType(        IntType ty){
          emit("String_Node_Str",-1);
        }
        public void caseLongType(        LongType ty){
          emit("String_Node_Str",0);
        }
        public void caseNullType(        NullType ty){
          emit("String_Node_Str",-1);
        }
        public void caseRefType(        RefType ty){
          emit("String_Node_Str",-1);
        }
        public void caseShortType(        ShortType ty){
          emit("String_Node_Str",-1);
        }
      }
);
    }
    public void caseCastExpr(    final CastExpr v){
      final Type toType=v.getCastType();
      final Type fromType=v.getOp().getType();
      emitValue(v.getOp());
      if (toType instanceof RefType)       emit("String_Node_Str" + slashify(toType.toString()),0);
 else       if (toType instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(toType),0);
 else {
        fromType.apply(new TypeSwitch(){
          public void defaultCase(          Type ty){
            throw new RuntimeException("String_Node_Str" + fromType);
          }
          public void caseDoubleType(          DoubleType ty){
            if (toType.equals(IntType.v()))             emit("String_Node_Str",-1);
 else             if (toType.equals(LongType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(FloatType.v()))             emit("String_Node_Str",-1);
 else             throw new RuntimeException("String_Node_Str" + toType);
          }
          public void caseFloatType(          FloatType ty){
            if (toType.equals(IntType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(LongType.v()))             emit("String_Node_Str",1);
 else             if (toType.equals(DoubleType.v()))             emit("String_Node_Str",1);
 else             throw new RuntimeException("String_Node_Str" + toType);
          }
          public void caseIntType(          IntType ty){
            emitIntToTypeCast();
          }
          public void caseBooleanType(          BooleanType ty){
            emitIntToTypeCast();
          }
          public void caseByteType(          ByteType ty){
            emitIntToTypeCast();
          }
          public void caseCharType(          CharType ty){
            emitIntToTypeCast();
          }
          public void caseShortType(          ShortType ty){
            emitIntToTypeCast();
          }
          private void emitIntToTypeCast(){
            if (toType.equals(ByteType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(CharType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(ShortType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(FloatType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(LongType.v()))             emit("String_Node_Str",1);
 else             if (toType.equals(DoubleType.v()))             emit("String_Node_Str",1);
 else             if (toType.equals(IntType.v()))             ;
 else             if (toType.equals(BooleanType.v()))             ;
 else             throw new RuntimeException("String_Node_Str" + toType + "String_Node_Str"+ v.toString());
          }
          public void caseLongType(          LongType ty){
            if (toType.equals(IntType.v()))             emit("String_Node_Str",-1);
 else             if (toType.equals(FloatType.v()))             emit("String_Node_Str",-1);
 else             if (toType.equals(DoubleType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(ByteType.v())) {
              emit("String_Node_Str",-1);
              emitIntToTypeCast();
            }
 else             if (toType.equals(ShortType.v())) {
              emit("String_Node_Str",-1);
              emitIntToTypeCast();
            }
 else             if (toType.equals(CharType.v())) {
              emit("String_Node_Str",-1);
              emitIntToTypeCast();
            }
 else             if (toType.equals(BooleanType.v())) {
              emit("String_Node_Str",-1);
              emitIntToTypeCast();
            }
 else             throw new RuntimeException("String_Node_Str" + toType);
          }
        }
);
      }
    }
    public void caseCmpExpr(    CmpExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      emit("String_Node_Str",-3);
    }
    public void caseCmpgExpr(    CmpgExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      if (v.getOp1().getType().equals(FloatType.v()))       emit("String_Node_Str",-1);
 else       emit("String_Node_Str",-3);
    }
    public void caseCmplExpr(    CmplExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      if (v.getOp1().getType().equals(FloatType.v()))       emit("String_Node_Str",-1);
 else       emit("String_Node_Str",-3);
    }
    public void defaultCase(    Value v){
      throw new RuntimeException("String_Node_Str" + v);
    }
    public void caseDivExpr(    DivExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseDoubleConstant(    DoubleConstant v){
      if (v.value == 0)       emit("String_Node_Str",2);
 else       if (v.value == 1)       emit("String_Node_Str",2);
 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,2);
      }
    }
    public void caseFloatConstant(    FloatConstant v){
      if (v.value == 0)       emit("String_Node_Str",1);
 else       if (v.value == 1)       emit("String_Node_Str",1);
 else       if (v.value == 2)       emit("String_Node_Str",1);
 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,1);
      }
    }
    public void caseInstanceFieldRef(    InstanceFieldRef v){
      emitValue(v.getBase());
      emit("String_Node_Str" + slashify(v.getField().getDeclaringClass().getName()) + "String_Node_Str"+ v.getField().getName()+ "String_Node_Str"+ jasminDescriptorOf(v.getField().getType()),-1 + sizeOfType(v.getField().getType()));
    }
    public void caseInstanceOfExpr(    InstanceOfExpr v){
      final Type checkType;
      emitValue(v.getOp());
      checkType=v.getCheckType();
      if (checkType instanceof RefType)       emit("String_Node_Str" + slashify(checkType.toString()),0);
 else       if (checkType instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(checkType),0);
    }
    public void caseIntConstant(    IntConstant v){
      if (v.value == -1)       emit("String_Node_Str",1);
 else       if (v.value >= 0 && v.value <= 5)       emit("String_Node_Str" + v.value,1);
 else       if (v.value >= Byte.MIN_VALUE && v.value <= Byte.MAX_VALUE)       emit("String_Node_Str" + v.value,1);
 else       if (v.value >= Short.MIN_VALUE && v.value <= Short.MAX_VALUE)       emit("String_Node_Str" + v.value,1);
 else       emit("String_Node_Str" + v.toString(),1);
    }
    public void caseInterfaceInvokeExpr(    InterfaceInvokeExpr v){
      SootMethod m=v.getMethod();
      emitValue(v.getBase());
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m)+ "String_Node_Str"+ (argCountOf(m) + 1),-(argCountOf(m) + 1) + sizeOfType(m.getReturnType()));
    }
    public void caseLengthExpr(    LengthExpr v){
      emitValue(v.getOp());
      emit("String_Node_Str",0);
    }
    public void caseLocal(    Local v){
      emitLocal(v);
    }
    public void caseLongConstant(    LongConstant v){
      if (v.value == 0)       emit("String_Node_Str",2);
 else       if (v.value == 1)       emit("String_Node_Str",2);
 else       emit("String_Node_Str" + v.toString(),2);
    }
    public void caseMulExpr(    MulExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseLtExpr(    LtExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseLeExpr(    LeExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseGtExpr(    GtExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseGeExpr(    GeExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseNeExpr(    NeExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseArrayType(        ArrayType t){
          emitBooleanBranch("String_Node_Str");
        }
        public void caseRefType(        RefType t){
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseEqExpr(    EqExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseArrayType(        ArrayType t){
          emitBooleanBranch("String_Node_Str");
        }
        public void casbeRefType(        RefType t){
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseNegExpr(    final NegExpr v){
      emitValue(v.getOp());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",0);
        }
        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",0);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",0);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",0);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t + "String_Node_Str"+ v);
        }
      }
);
    }
    public void caseNewArrayExpr(    NewArrayExpr v){
      Value size=v.getSize();
      emitValue(size);
      if (v.getBaseType() instanceof RefType)       emit("String_Node_Str" + slashify(v.getBaseType().toString()),0);
 else       if (v.getBaseType() instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(v.getBaseType()),0);
 else       emit("String_Node_Str" + v.getBaseType().toString(),0);
    }
    public void caseNewMultiArrayExpr(    NewMultiArrayExpr v){
      List sizes=v.getSizes();
      for (int i=0; i < sizes.size(); i++)       emitValue((Value)sizes.get(i));
      emit("String_Node_Str" + jasminDescriptorOf(v.getBaseType()) + "String_Node_Str"+ sizes.size(),-sizes.size() + 1);
    }
    public void caseNewExpr(    NewExpr v){
      emit("String_Node_Str" + slashify(v.getBaseType().toString()),1);
    }
    public void caseNewInvokeExpr(    NewInvokeExpr v){
      emit("String_Node_Str" + slashify(v.getBaseType().toString()),1);
      emit("String_Node_Str",1);
      SootMethod m=v.getMethod();
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m),-(argCountOf(m) + 1) + sizeOfType(m.getReturnType()));
    }
    public void caseNullConstant(    NullConstant v){
      emit("String_Node_Str",1);
    }
    public void caseOrExpr(    OrExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseRemExpr(    RemExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseShlExpr(    ShlExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseShrExpr(    ShrExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseSpecialInvokeExpr(    SpecialInvokeExpr v){
      SootMethod m=v.getMethod();
      emitValue(v.getBase());
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m),-(argCountOf(m) + 1) + sizeOfType(m.getReturnType()));
    }
    public void caseStaticInvokeExpr(    StaticInvokeExpr v){
      SootMethod m=v.getMethod();
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m),-(argCountOf(m)) + sizeOfType(m.getReturnType()));
    }
    public void caseStaticFieldRef(    StaticFieldRef v){
      emit("String_Node_Str" + slashify(v.getField().getDeclaringClass().getName()) + "String_Node_Str"+ v.getField().getName()+ "String_Node_Str"+ jasminDescriptorOf(v.getField().getType()),sizeOfType(v.getField().getType()));
    }
    public void caseStringConstant(    StringConstant v){
      emit("String_Node_Str" + v.toString(),1);
    }
    public void caseSubExpr(    SubExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseUshrExpr(    UshrExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseVirtualInvokeExpr(    VirtualInvokeExpr v){
      SootMethod m=v.getMethod();
      emitValue(v.getBase());
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m),-(argCountOf(m) + 1) + sizeOfType(m.getReturnType()));
    }
    public void caseXorExpr(    XorExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
  }
);
}

Fixed version (ground truth):
void emitValue(Value value){
  value.apply(new AbstractGrimpValueSwitch(){
    public void caseAddExpr(    AddExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseAndExpr(    AndExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseArrayRef(    ArrayRef v){
      emitValue(v.getBase());
      emitValue(v.getIndex());
      v.getType().apply(new TypeSwitch(){
        public void caseArrayType(        ArrayType ty){
          emit("String_Node_Str",-1);
        }
        public void caseBooleanType(        BooleanType ty){
          emit("String_Node_Str",-1);
        }
        public void caseByteType(        ByteType ty){
          emit("String_Node_Str",-1);
        }
        public void caseCharType(        CharType ty){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type ty){
          throw new RuntimeException("String_Node_Str");
        }
        public void caseDoubleType(        DoubleType ty){
          emit("String_Node_Str",0);
        }
        public void caseFloatType(        FloatType ty){
          emit("String_Node_Str",-1);
        }
        public void caseIntType(        IntType ty){
          emit("String_Node_Str",-1);
        }
        public void caseLongType(        LongType ty){
          emit("String_Node_Str",0);
        }
        public void caseNullType(        NullType ty){
          emit("String_Node_Str",-1);
        }
        public void caseRefType(        RefType ty){
          emit("String_Node_Str",-1);
        }
        public void caseShortType(        ShortType ty){
          emit("String_Node_Str",-1);
        }
      }
);
    }
    public void caseCastExpr(    final CastExpr v){
      final Type toType=v.getCastType();
      final Type fromType=v.getOp().getType();
      emitValue(v.getOp());
      if (toType instanceof RefType)       emit("String_Node_Str" + slashify(toType.toString()),0);
 else       if (toType instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(toType),0);
 else {
        fromType.apply(new TypeSwitch(){
          public void defaultCase(          Type ty){
            throw new RuntimeException("String_Node_Str" + fromType);
          }
          public void caseDoubleType(          DoubleType ty){
            if (toType.equals(IntType.v()))             emit("String_Node_Str",-1);
 else             if (toType.equals(LongType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(FloatType.v()))             emit("String_Node_Str",-1);
 else             throw new RuntimeException("String_Node_Str" + toType);
          }
          public void caseFloatType(          FloatType ty){
            if (toType.equals(IntType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(LongType.v()))             emit("String_Node_Str",1);
 else             if (toType.equals(DoubleType.v()))             emit("String_Node_Str",1);
 else             throw new RuntimeException("String_Node_Str" + toType);
          }
          public void caseIntType(          IntType ty){
            emitIntToTypeCast();
          }
          public void caseBooleanType(          BooleanType ty){
            emitIntToTypeCast();
          }
          public void caseByteType(          ByteType ty){
            emitIntToTypeCast();
          }
          public void caseCharType(          CharType ty){
            emitIntToTypeCast();
          }
          public void caseShortType(          ShortType ty){
            emitIntToTypeCast();
          }
          private void emitIntToTypeCast(){
            if (toType.equals(ByteType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(CharType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(ShortType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(FloatType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(LongType.v()))             emit("String_Node_Str",1);
 else             if (toType.equals(DoubleType.v()))             emit("String_Node_Str",1);
 else             if (toType.equals(IntType.v()))             ;
 else             if (toType.equals(BooleanType.v()))             ;
 else             throw new RuntimeException("String_Node_Str" + toType + "String_Node_Str"+ v.toString());
          }
          public void caseLongType(          LongType ty){
            if (toType.equals(IntType.v()))             emit("String_Node_Str",-1);
 else             if (toType.equals(FloatType.v()))             emit("String_Node_Str",-1);
 else             if (toType.equals(DoubleType.v()))             emit("String_Node_Str",0);
 else             if (toType.equals(ByteType.v())) {
              emit("String_Node_Str",-1);
              emitIntToTypeCast();
            }
 else             if (toType.equals(ShortType.v())) {
              emit("String_Node_Str",-1);
              emitIntToTypeCast();
            }
 else             if (toType.equals(CharType.v())) {
              emit("String_Node_Str",-1);
              emitIntToTypeCast();
            }
 else             if (toType.equals(BooleanType.v())) {
              emit("String_Node_Str",-1);
              emitIntToTypeCast();
            }
 else             throw new RuntimeException("String_Node_Str" + toType);
          }
        }
);
      }
    }
    public void caseCmpExpr(    CmpExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      emit("String_Node_Str",-3);
    }
    public void caseCmpgExpr(    CmpgExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      if (v.getOp1().getType().equals(FloatType.v()))       emit("String_Node_Str",-1);
 else       emit("String_Node_Str",-3);
    }
    public void caseCmplExpr(    CmplExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      if (v.getOp1().getType().equals(FloatType.v()))       emit("String_Node_Str",-1);
 else       emit("String_Node_Str",-3);
    }
    public void defaultCase(    Value v){
      throw new RuntimeException("String_Node_Str" + v);
    }
    public void caseDivExpr(    DivExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseDoubleConstant(    DoubleConstant v){
      if ((v.value == 0) && ((1.0 / v.value) > 0.0))       emit("String_Node_Str",2);
 else       if (v.value == 1)       emit("String_Node_Str",2);
 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,2);
      }
    }
    public void caseFloatConstant(    FloatConstant v){
      if ((v.value == 0) && ((1.0f / v.value) > 0.0f))       emit("String_Node_Str",1);
 else       if (v.value == 1)       emit("String_Node_Str",1);
 else       if (v.value == 2)       emit("String_Node_Str",1);
 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,1);
      }
    }
    public void caseInstanceFieldRef(    InstanceFieldRef v){
      emitValue(v.getBase());
      emit("String_Node_Str" + slashify(v.getField().getDeclaringClass().getName()) + "String_Node_Str"+ v.getField().getName()+ "String_Node_Str"+ jasminDescriptorOf(v.getField().getType()),-1 + sizeOfType(v.getField().getType()));
    }
    public void caseInstanceOfExpr(    InstanceOfExpr v){
      final Type checkType;
      emitValue(v.getOp());
      checkType=v.getCheckType();
      if (checkType instanceof RefType)       emit("String_Node_Str" + slashify(checkType.toString()),0);
 else       if (checkType instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(checkType),0);
    }
    public void caseIntConstant(    IntConstant v){
      if (v.value == -1)       emit("String_Node_Str",1);
 else       if (v.value >= 0 && v.value <= 5)       emit("String_Node_Str" + v.value,1);
 else       if (v.value >= Byte.MIN_VALUE && v.value <= Byte.MAX_VALUE)       emit("String_Node_Str" + v.value,1);
 else       if (v.value >= Short.MIN_VALUE && v.value <= Short.MAX_VALUE)       emit("String_Node_Str" + v.value,1);
 else       emit("String_Node_Str" + v.toString(),1);
    }
    public void caseInterfaceInvokeExpr(    InterfaceInvokeExpr v){
      SootMethod m=v.getMethod();
      emitValue(v.getBase());
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m)+ "String_Node_Str"+ (argCountOf(m) + 1),-(argCountOf(m) + 1) + sizeOfType(m.getReturnType()));
    }
    public void caseLengthExpr(    LengthExpr v){
      emitValue(v.getOp());
      emit("String_Node_Str",0);
    }
    public void caseLocal(    Local v){
      emitLocal(v);
    }
    public void caseLongConstant(    LongConstant v){
      if (v.value == 0)       emit("String_Node_Str",2);
 else       if (v.value == 1)       emit("String_Node_Str",2);
 else       emit("String_Node_Str" + v.toString(),2);
    }
    public void caseMulExpr(    MulExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseLtExpr(    LtExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseLeExpr(    LeExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseGtExpr(    GtExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseGeExpr(    GeExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseNeExpr(    NeExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseArrayType(        ArrayType t){
          emitBooleanBranch("String_Node_Str");
        }
        public void caseRefType(        RefType t){
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseEqExpr(    EqExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getOp1().getType().apply(new TypeSwitch(){
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        private void handleIntCase(){
          emit("String_Node_Str",-2);
        }
        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",-3);
          emit("String_Node_Str",1);
          emitBooleanBranch("String_Node_Str");
        }
        public void caseArrayType(        ArrayType t){
          emitBooleanBranch("String_Node_Str");
        }
        public void casbeRefType(        RefType t){
          emitBooleanBranch("String_Node_Str");
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseNegExpr(    final NegExpr v){
      emitValue(v.getOp());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",0);
        }
        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",0);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",0);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",0);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str" + t + "String_Node_Str"+ v);
        }
      }
);
    }
    public void caseNewArrayExpr(    NewArrayExpr v){
      Value size=v.getSize();
      emitValue(size);
      if (v.getBaseType() instanceof RefType)       emit("String_Node_Str" + slashify(v.getBaseType().toString()),0);
 else       if (v.getBaseType() instanceof ArrayType)       emit("String_Node_Str" + jasminDescriptorOf(v.getBaseType()),0);
 else       emit("String_Node_Str" + v.getBaseType().toString(),0);
    }
    public void caseNewMultiArrayExpr(    NewMultiArrayExpr v){
      List sizes=v.getSizes();
      for (int i=0; i < sizes.size(); i++)       emitValue((Value)sizes.get(i));
      emit("String_Node_Str" + jasminDescriptorOf(v.getBaseType()) + "String_Node_Str"+ sizes.size(),-sizes.size() + 1);
    }
    public void caseNewExpr(    NewExpr v){
      emit("String_Node_Str" + slashify(v.getBaseType().toString()),1);
    }
    public void caseNewInvokeExpr(    NewInvokeExpr v){
      emit("String_Node_Str" + slashify(v.getBaseType().toString()),1);
      emit("String_Node_Str",1);
      SootMethod m=v.getMethod();
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m),-(argCountOf(m) + 1) + sizeOfType(m.getReturnType()));
    }
    public void caseNullConstant(    NullConstant v){
      emit("String_Node_Str",1);
    }
    public void caseOrExpr(    OrExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseRemExpr(    RemExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseShlExpr(    ShlExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseShrExpr(    ShrExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseSpecialInvokeExpr(    SpecialInvokeExpr v){
      SootMethod m=v.getMethod();
      emitValue(v.getBase());
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m),-(argCountOf(m) + 1) + sizeOfType(m.getReturnType()));
    }
    public void caseStaticInvokeExpr(    StaticInvokeExpr v){
      SootMethod m=v.getMethod();
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m),-(argCountOf(m)) + sizeOfType(m.getReturnType()));
    }
    public void caseStaticFieldRef(    StaticFieldRef v){
      emit("String_Node_Str" + slashify(v.getField().getDeclaringClass().getName()) + "String_Node_Str"+ v.getField().getName()+ "String_Node_Str"+ jasminDescriptorOf(v.getField().getType()),sizeOfType(v.getField().getType()));
    }
    public void caseStringConstant(    StringConstant v){
      emit("String_Node_Str" + v.toString(),1);
    }
    public void caseSubExpr(    SubExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void caseDoubleType(        DoubleType t){
          emit("String_Node_Str",-2);
        }
        public void caseFloatType(        FloatType t){
          emit("String_Node_Str",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseUshrExpr(    UshrExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-1);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
    public void caseVirtualInvokeExpr(    VirtualInvokeExpr v){
      SootMethod m=v.getMethod();
      emitValue(v.getBase());
      for (int i=0; i < m.getParameterCount(); i++)       emitValue(v.getArg(i));
      emit("String_Node_Str" + slashify(m.getDeclaringClass().getName()) + "String_Node_Str"+ m.getName()+ jasminDescriptorOf(m),-(argCountOf(m) + 1) + sizeOfType(m.getReturnType()));
    }
    public void caseXorExpr(    XorExpr v){
      emitValue(v.getOp1());
      emitValue(v.getOp2());
      v.getType().apply(new TypeSwitch(){
        private void handleIntCase(){
          emit("String_Node_Str",-1);
        }
        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",-2);
        }
        public void defaultCase(        Type t){
          throw new RuntimeException("String_Node_Str");
        }
      }
);
    }
  }
);
}