Input:
public ContextMap<CallString, Map<Location, ValueMapping>> transfer(InstructionHandle stmt, FlowEdge edge, ContextMap<CallString, Map<Location, ValueMapping>> input, Interpreter<CallString, Map<Location, ValueMapping>> interpreter, Map<InstructionHandle, ContextMap<CallString, Map<Location, ValueMapping>>> state) {
    Context context = new Context(input.getContext());
    Map<Location, ValueMapping> in = (Map<Location, ValueMapping>) input.get(context.callString);
    ContextMap<CallString, Map<Location, ValueMapping>> retval = new ContextMap<CallString, Map<Location, ValueMapping>>(context, new HashMap<CallString, Map<Location, ValueMapping>>());
    Instruction instruction = stmt.getInstruction();
    if (in == null) {
        context.stackPtr += instruction.produceStack(context.constPool) - instruction.consumeStack(context.constPool);
        return retval;
    }
    Map<Location, ValueMapping> result = new HashMap<Location, ValueMapping>();
    retval.put(context.callString, result);
    switch(instruction.getOpcode()) {
        case Constants.ICONST_M1:
        case Constants.ICONST_0:
        case Constants.ICONST_1:
        case Constants.ICONST_2:
        case Constants.ICONST_3:
        case Constants.ICONST_4:
        case Constants.ICONST_5:
        case Constants.BIPUSH:
        case Constants.SIPUSH:
            {
                ConstantPushInstruction instr = (ConstantPushInstruction) instruction;
                result = new HashMap<Location, ValueMapping>(in);
                retval.put(context.callString, result);
                int value = instr.getValue().intValue();
                result.put(new Location(context.stackPtr), new ValueMapping(value));
            }
            break;
        case Constants.ACONST_NULL:
            result = in;
            retval.put(context.callString, result);
            break;
        case Constants.LDC:
        case Constants.LDC_W:
            {
                LDC instr = (LDC) instruction;
                result = new HashMap<Location, ValueMapping>(in);
                retval.put(context.callString, result);
                Type type = instr.getType(context.constPool);
                if (type.equals(Type.INT)) {
                    Integer value = (Integer) instr.getValue(context.constPool);
                    result.put(new Location(context.stackPtr), new ValueMapping(value));
                } else if (type.equals(Type.STRING)) {
                    String value = (String) instr.getValue(context.constPool);
                    String name = "String_Node_Str";
                    name += "String_Node_Str" + context.method + "String_Node_Str" + stmt.getPosition();
                    result.put(new Location(name + "String_Node_Str"), new ValueMapping(value.length()));
                }
            }
            break;
        case Constants.LDC2_W:
            result = in;
            retval.put(context.callString, result);
            break;
        case Constants.ISTORE_0:
        case Constants.ISTORE_1:
        case Constants.ISTORE_2:
        case Constants.ISTORE_3:
        case Constants.ISTORE:
            {
                StoreInstruction instr = (StoreInstruction) instruction;
                int index = instr.getIndex();
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 1 && l.stackLoc != index) {
                        result.put(l, in.get(l));
                    }
                    if (l.stackLoc == context.stackPtr - 1) {
                        ValueMapping v = new ValueMapping(in.get(l), true);
                        if (in.get(l).source == null || in.get(l).source.stackLoc != index) {
                            v.defscope = ValueMapping.scope;
                        }
                        result.put(new Location(index), v);
                    }
                }
            }
            break;
        case Constants.ASTORE_0:
        case Constants.ASTORE_1:
        case Constants.ASTORE_2:
        case Constants.ASTORE_3:
        case Constants.ASTORE:
            result = in;
            retval.put(context.callString, result);
            break;
        case Constants.LSTORE_0:
        case Constants.LSTORE_1:
        case Constants.LSTORE_2:
        case Constants.LSTORE_3:
        case Constants.LSTORE:
            filterSet(in, result, context.stackPtr - 2);
            break;
        case Constants.ILOAD_0:
        case Constants.ILOAD_1:
        case Constants.ILOAD_2:
        case Constants.ILOAD_3:
        case Constants.ILOAD:
            {
                LoadInstruction instr = (LoadInstruction) instruction;
                filterSet(in, result, context.stackPtr);
                int index = instr.getIndex();
                for (Location l : in.keySet()) {
                    if (l.stackLoc == index) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.source = l;
                        result.put(new Location(context.stackPtr), m);
                    }
                }
            }
            break;
        case Constants.ALOAD_0:
        case Constants.ALOAD_1:
        case Constants.ALOAD_2:
        case Constants.ALOAD_3:
        case Constants.ALOAD:
            result = in;
            retval.put(context.callString, result);
            break;
        case Constants.ARRAYLENGTH:
            {
                filterSet(in, result, context.stackPtr - 1);
                DFATool p = interpreter.getProgram();
                Set<String> receivers = p.getReceivers(stmt, context.callString);
                Location location = new Location(context.stackPtr - 1);
                boolean valid = false;
                if (receivers == null) {
                    System.out.println("String_Node_Str" + context.callString.toStringList() + context.method + stmt);
                } else {
                    for (String arrayName : receivers) {
                        ValueMapping m = in.get(new Location(arrayName + "String_Node_Str"));
                        if (m != null) {
                            ValueMapping value = new ValueMapping(m, false);
                            value.join(result.get(location));
                            result.put(location, value);
                            valid = true;
                        }
                    }
                }
                if (!valid) {
                    result.put(new Location(context.stackPtr - 1), new ValueMapping());
                }
            }
            break;
        case Constants.PUTFIELD:
            {
                PUTFIELD instr = (PUTFIELD) instruction;
                int fieldSize = instr.getFieldType(context.constPool).getSize();
                for (Location l : in.keySet()) {
                    if (l.stackLoc >= 0 && l.stackLoc < context.stackPtr - 1 - fieldSize) {
                        result.put(l, in.get(l));
                    }
                }
                DFATool p = interpreter.getProgram();
                Set<String> receivers = p.getReceivers(stmt, context.callString);
                if (receivers == null) {
                    System.out.println("String_Node_Str" + context.callString.toStringList() + context.method + stmt);
                } else {
                    for (String fieldName : receivers) {
                        String f = fieldName.substring(fieldName.lastIndexOf("String_Node_Str"), fieldName.length());
                        String strippedName;
                        if (fieldName.indexOf("String_Node_Str") >= 0) {
                            strippedName = fieldName.split("String_Node_Str")[0] + f;
                        } else {
                            strippedName = fieldName;
                        }
                        if (p.containsField(strippedName)) {
                            for (Location l : in.keySet()) {
                                if (l.stackLoc < 0 && !receivers.contains(l.heapLoc)) {
                                    result.put(l, in.get(l));
                                }
                                if (l.stackLoc == context.stackPtr - 1) {
                                    result.put(new Location(fieldName), new ValueMapping(in.get(l), false));
                                }
                            }
                        }
                    }
                }
            }
            break;
        case Constants.GETFIELD:
            {
                GETFIELD instr = (GETFIELD) instruction;
                filterSet(in, result, context.stackPtr - 1);
                DFATool p = interpreter.getProgram();
                Set<String> receivers = p.getReceivers(stmt, context.callString);
                Location location = new Location(context.stackPtr - 1);
                boolean valid = false;
                if (receivers == null) {
                    System.out.println("String_Node_Str" + context.callString.toStringList() + context.method + stmt);
                } else {
                    for (Iterator<String> i = receivers.iterator(); i.hasNext(); ) {
                        String fieldName = i.next();
                        String f = fieldName.substring(fieldName.lastIndexOf("String_Node_Str"), fieldName.length());
                        String strippedName;
                        if (fieldName.indexOf("String_Node_Str") >= 0) {
                            strippedName = fieldName.split("String_Node_Str")[0] + f;
                        } else {
                            strippedName = fieldName;
                        }
                        if (p.containsField(strippedName)) {
                            for (Iterator<Location> k = in.keySet().iterator(); k.hasNext(); ) {
                                Location l = k.next();
                                if (l.heapLoc.equals(fieldName)) {
                                    ValueMapping value = new ValueMapping(in.get(l), false);
                                    value.join(result.get(location));
                                    result.put(location, value);
                                    valid = true;
                                }
                            }
                        }
                    }
                }
                if (!valid && !(instr.getFieldType(context.constPool) instanceof ReferenceType)) {
                    result.put(new Location(context.stackPtr - 1), new ValueMapping());
                }
            }
            break;
        case Constants.PUTSTATIC:
            {
                PUTSTATIC instr = (PUTSTATIC) instruction;
                int fieldSize = instr.getFieldType(context.constPool).getSize();
                for (Iterator<Location> i = in.keySet().iterator(); i.hasNext(); ) {
                    Location l = i.next();
                    if (l.stackLoc >= 0 && l.stackLoc < context.stackPtr - fieldSize) {
                        result.put(l, in.get(l));
                    }
                }
                DFATool p = interpreter.getProgram();
                Set<String> receivers = p.getReceivers(stmt, context.callString);
                for (Iterator<String> i = receivers.iterator(); i.hasNext(); ) {
                    String fieldName = i.next();
                    if (p.containsField(fieldName)) {
                        for (Iterator<Location> k = in.keySet().iterator(); k.hasNext(); ) {
                            Location l = k.next();
                            if (l.stackLoc < 0 && !receivers.contains(l.heapLoc)) {
                                result.put(l, in.get(l));
                            }
                            if (l.stackLoc == context.stackPtr - 1) {
                                result.put(new Location(fieldName), new ValueMapping(in.get(l), false));
                            }
                        }
                    }
                }
            }
            break;
        case Constants.GETSTATIC:
            {
                GETSTATIC instr = (GETSTATIC) instruction;
                result = new HashMap<Location, ValueMapping>(in);
                retval.put(context.callString, result);
                DFATool p = interpreter.getProgram();
                Set<String> receivers = p.getReceivers(stmt, context.callString);
                Location location = new Location(context.stackPtr);
                boolean valid = false;
                for (String fieldName : receivers) {
                    if (p.containsField(fieldName)) {
                        for (Location l : in.keySet()) {
                            if (l.heapLoc.equals(fieldName)) {
                                ValueMapping value = new ValueMapping(in.get(l), false);
                                value.join(result.get(location));
                                result.put(location, value);
                                valid = true;
                            }
                        }
                    }
                }
                if (!valid && !(instr.getFieldType(context.constPool) instanceof ReferenceType)) {
                    result.put(new Location(context.stackPtr), new ValueMapping());
                }
            }
            break;
        case Constants.IASTORE:
        case Constants.CASTORE:
        case Constants.SASTORE:
        case Constants.BASTORE:
            {
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 3) {
                        result.put(l, in.get(l));
                    }
                }
                DFATool p = interpreter.getProgram();
                Set<String> receivers = p.getReceivers(stmt, context.callString);
                if (receivers == null) {
                    System.out.println("String_Node_Str" + context.callString.toStringList() + context.method + stmt);
                    break;
                }
                for (String name : receivers) {
                    for (Location l : in.keySet()) {
                        if (l.stackLoc == context.stackPtr - 1) {
                            Location loc = new Location(name);
                            ValueMapping val = new ValueMapping(in.get(l), false);
                            val.join(in.get(loc));
                            result.put(loc, val);
                        }
                    }
                }
            }
            break;
        case Constants.AASTORE:
            {
                filterSet(in, result, context.stackPtr - 3);
            }
            break;
        case Constants.IALOAD:
        case Constants.CALOAD:
        case Constants.SALOAD:
        case Constants.BALOAD:
            {
                filterSet(in, result, context.stackPtr - 2);
                DFATool p = interpreter.getProgram();
                Location location = new Location(context.stackPtr - 2);
                boolean valid = false;
                Set<String> receivers = p.getReceivers(stmt, context.callString);
                for (String name : receivers) {
                    for (Location l : in.keySet()) {
                        if (l.heapLoc.equals(name)) {
                            ValueMapping value = new ValueMapping(in.get(l), false);
                            value.join(result.get(location));
                            result.put(location, value);
                            valid = true;
                        }
                    }
                }
                if (!valid) {
                    result.put(new Location(context.stackPtr - 2), new ValueMapping(0));
                }
            }
            break;
        case Constants.AALOAD:
            {
                ValueMapping v = in.get(new Location(context.stackPtr - 1));
                if (v == null) {
                    System.out.println("String_Node_Str" + context.callString.toStringList() + context.method + stmt);
                } else {
                    recordArrayIndex(stmt, context, v.assigned);
                }
                filterSet(in, result, context.stackPtr - 2);
            }
            break;
        case Constants.DUP:
            {
                for (Location l : in.keySet()) {
                    result.put(l, in.get(l));
                    if (l.stackLoc == context.stackPtr - 1) {
                        result.put(new Location(context.stackPtr), new ValueMapping(in.get(l), true));
                    }
                }
            }
            break;
        case Constants.DUP_X1:
            {
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 2) {
                        result.put(l, in.get(l));
                    }
                    if (l.stackLoc == context.stackPtr - 1) {
                        result.put(new Location(context.stackPtr - 2), new ValueMapping(in.get(l), true));
                        result.put(new Location(context.stackPtr), new ValueMapping(in.get(l), true));
                    }
                    if (l.stackLoc == context.stackPtr - 2) {
                        result.put(new Location(context.stackPtr - 1), new ValueMapping(in.get(l), true));
                    }
                }
            }
            break;
        case Constants.DUP2:
            {
                for (Location l : in.keySet()) {
                    result.put(l, in.get(l));
                    if (l.stackLoc == context.stackPtr - 2) {
                        result.put(new Location(context.stackPtr), new ValueMapping(in.get(l), true));
                    }
                    if (l.stackLoc == context.stackPtr - 1) {
                        result.put(new Location(context.stackPtr + 1), new ValueMapping(in.get(l), true));
                    }
                }
            }
            break;
        case Constants.POP:
            {
                filterSet(in, result, context.stackPtr - 1);
            }
            break;
        case Constants.POP2:
            {
                filterSet(in, result, context.stackPtr - 2);
            }
            break;
        case Constants.IINC:
            {
                IINC instr = (IINC) instruction;
                int index = instr.getIndex();
                int increment = instr.getIncrement();
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr) {
                        result.put(l, in.get(l));
                    }
                    if (l.stackLoc == index) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.assigned.add(increment);
                        m.constrained.add(increment);
                        Interval operand = new Interval(increment, increment);
                        if (m.increment != null && !m.softinc) {
                            m.increment.join(operand);
                        } else if (m.increment != null && m.softinc) {
                            if ((m.increment.getLb() < 0 && operand.getUb() > 0) || (m.increment.getUb() > 0 && operand.getLb() < 0)) {
                                m.increment.join(operand);
                            } else {
                                m.increment = operand;
                            }
                            m.softinc = false;
                        } else {
                            m.increment = operand;
                            m.softinc = false;
                        }
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.IADD:
            {
                Interval operand = new Interval();
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        operand = in.get(l).assigned;
                    }
                }
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 2) {
                        result.put(l, in.get(l));
                    } else if (l.stackLoc == context.stackPtr - 2) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.assigned.add(operand);
                        m.constrained.add(operand);
                        if (m.increment != null && !m.softinc) {
                            m.increment.join(operand);
                        } else if (m.increment != null && m.softinc) {
                            if ((m.increment.getLb() < 0 && operand.getUb() > 0) || (m.increment.getUb() > 0 && operand.getLb() < 0)) {
                                m.increment.join(operand);
                            } else {
                                m.increment = operand;
                            }
                            m.softinc = false;
                        } else {
                            m.increment = operand;
                            m.softinc = false;
                        }
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.ISUB:
            {
                Interval operand = new Interval();
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        operand = in.get(l).assigned;
                    }
                }
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 2) {
                        result.put(l, in.get(l));
                    } else if (l.stackLoc == context.stackPtr - 2) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.assigned.sub(operand);
                        m.constrained.sub(operand);
                        operand.neg();
                        if (m.increment != null && !m.softinc) {
                            m.increment.join(operand);
                        } else if (m.increment != null && m.softinc) {
                            if ((m.increment.getLb() < 0 && operand.getUb() > 0) || (m.increment.getUb() > 0 && operand.getLb() < 0)) {
                                m.increment.join(operand);
                            } else {
                                m.increment = operand;
                            }
                            m.softinc = false;
                        } else {
                            m.increment = operand;
                            m.softinc = false;
                        }
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.INEG:
            {
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 1) {
                        result.put(l, in.get(l));
                    } else if (l.stackLoc == context.stackPtr - 1) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.assigned.neg();
                        m.constrained.neg();
                        m.increment = new Interval();
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.IUSHR:
            {
                Interval operand = new Interval();
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        operand = in.get(l).assigned;
                    }
                }
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 2) {
                        result.put(l, in.get(l));
                    } else if (l.stackLoc == context.stackPtr - 2) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.assigned.ushr(operand);
                        m.constrained.ushr(operand);
                        m.increment = new Interval();
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.ISHR:
            {
                Interval operand = new Interval();
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        operand = in.get(l).assigned;
                    }
                }
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 2) {
                        result.put(l, in.get(l));
                    } else if (l.stackLoc == context.stackPtr - 2) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.assigned.shr(operand);
                        m.constrained.shr(operand);
                        m.increment = new Interval();
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.IMUL:
            {
                Interval operand = new Interval();
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        operand = in.get(l).assigned;
                    }
                }
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 2) {
                        result.put(l, in.get(l));
                    } else if (l.stackLoc == context.stackPtr - 2) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.assigned.mul(operand);
                        m.constrained.mul(operand);
                        m.increment = new Interval();
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.IDIV:
            {
                Interval operand = new Interval();
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        operand = in.get(l).assigned;
                    }
                }
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 2) {
                        result.put(l, in.get(l));
                    } else if (l.stackLoc == context.stackPtr - 2) {
                        ValueMapping m = new ValueMapping(in.get(l), true);
                        m.assigned.div(operand);
                        m.constrained.div(operand);
                        m.increment = new Interval();
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.IAND:
        case Constants.IOR:
        case Constants.IXOR:
        case Constants.IREM:
        case Constants.ISHL:
            {
                for (Location l : in.keySet()) {
                    if (l.stackLoc < context.stackPtr - 2) {
                        result.put(l, in.get(l));
                    } else if (l.stackLoc == context.stackPtr - 2) {
                        ValueMapping m = new ValueMapping();
                        result.put(l, m);
                    }
                }
            }
            break;
        case Constants.I2B:
        case Constants.I2C:
        case Constants.I2S:
            result = in;
            retval.put(context.callString, result);
            break;
        case Constants.MONITORENTER:
            result = in;
            retval.put(context.callString, result);
            context.syncLevel++;
            break;
        case Constants.MONITOREXIT:
            result = in;
            retval.put(context.callString, result);
            context.syncLevel--;
            if (context.syncLevel < 0) {
                System.err.println("String_Node_Str");
                System.exit(-1);
            }
            break;
        case Constants.CHECKCAST:
            result = in;
            retval.put(context.callString, result);
            break;
        case Constants.INSTANCEOF:
            {
                filterSet(in, result, context.stackPtr - 1);
                ValueMapping bool = new ValueMapping();
                bool.assigned.setLb(0);
                bool.assigned.setUb(1);
                result.put(new Location(context.stackPtr - 1), bool);
            }
            break;
        case Constants.NEW:
            {
                result = in;
                retval.put(context.callString, result);
            }
            break;
        case Constants.NEWARRAY:
            {
                NEWARRAY instr = (NEWARRAY) instruction;
                String name = instr.getType().toString();
                name += "String_Node_Str" + context.method + "String_Node_Str" + stmt.getPosition();
                filterSet(in, result, context.stackPtr - 1);
                boolean valid = false;
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        result.put(new Location(name + "String_Node_Str"), in.get(l));
                        recordSize(stmt, context, in.get(l).assigned);
                        valid = true;
                    }
                }
                if (!valid) {
                    ValueMapping v = new ValueMapping();
                    result.put(new Location(name + "String_Node_Str"), v);
                    recordSize(stmt, context, v.assigned);
                }
            }
            break;
        case Constants.ANEWARRAY:
            {
                ANEWARRAY instr = (ANEWARRAY) instruction;
                String name = instr.getType(context.constPool).toString() + "String_Node_Str";
                name += "String_Node_Str" + context.method + "String_Node_Str" + stmt.getPosition();
                filterSet(in, result, context.stackPtr - 1);
                boolean valid = false;
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        result.put(new Location(name + "String_Node_Str"), in.get(l));
                        recordSize(stmt, context, in.get(l).assigned);
                        valid = true;
                    }
                }
                if (!valid) {
                    ValueMapping v = new ValueMapping();
                    result.put(new Location(name + "String_Node_Str"), v);
                    recordSize(stmt, context, v.assigned);
                }
            }
            break;
        case Constants.MULTIANEWARRAY:
            {
                MULTIANEWARRAY instr = (MULTIANEWARRAY) instruction;
                int dim = instr.getDimensions();
                filterSet(in, result, context.stackPtr - dim);
                String type = instr.getType(context.constPool).toString();
                type = type.substring(0, type.indexOf("String_Node_Str"));
                Interval[] size = new Interval[dim];
                for (int i = 1; i <= dim; i++) {
                    String name = type;
                    for (int k = 0; k < i; k++) {
                        name += "String_Node_Str";
                    }
                    name += "String_Node_Str" + context.method + "String_Node_Str" + stmt.getPosition();
                    boolean valid = false;
                    for (Location l : in.keySet()) {
                        if (l.stackLoc == context.stackPtr - i) {
                            result.put(new Location(name + "String_Node_Str"), in.get(l));
                            if (size[i - 1] != null) {
                                size[i - 1].join(in.get(l).assigned);
                            } else {
                                size[i - 1] = in.get(l).assigned;
                            }
                            valid = true;
                        }
                    }
                    if (!valid) {
                        ValueMapping v = new ValueMapping();
                        result.put(new Location(name + "String_Node_Str"), v);
                        size[i - 1] = v.assigned;
                    }
                }
                recordSize(stmt, context, size);
            }
            break;
        case Constants.GOTO:
            result = in;
            retval.put(context.callString, result);
            break;
        case Constants.IFNULL:
        case Constants.IFNONNULL:
            {
                checkScope(context, stmt);
                filterSet(in, result, context.stackPtr - 1);
            }
            break;
        case Constants.IF_ACMPEQ:
        case Constants.IF_ACMPNE:
            {
                checkScope(context, stmt);
                filterSet(in, result, context.stackPtr - 2);
            }
            break;
        case Constants.IFEQ:
        case Constants.IFNE:
        case Constants.IFLT:
        case Constants.IFGE:
        case Constants.IFLE:
        case Constants.IFGT:
            checkScope(context, stmt);
            result = doIf(stmt, edge, context, in, result);
            retval.put(context.callString, result);
            break;
        case Constants.IF_ICMPEQ:
        case Constants.IF_ICMPNE:
        case Constants.IF_ICMPLT:
        case Constants.IF_ICMPGE:
        case Constants.IF_ICMPGT:
        case Constants.IF_ICMPLE:
            checkScope(context, stmt);
            result = doIfIcmp(stmt, edge, context, in, result);
            retval.put(context.callString, result);
            break;
        case Constants.LOOKUPSWITCH:
        case Constants.TABLESWITCH:
            result = in;
            retval.put(context.callString, result);
            break;
        case Constants.INVOKEVIRTUAL:
        case Constants.INVOKEINTERFACE:
        case Constants.INVOKESTATIC:
        case Constants.INVOKESPECIAL:
            {
                DFATool p = interpreter.getProgram();
                Set<String> receivers = p.getReceivers(stmt, context.callString);
                if (receivers == null) {
                    System.out.println(context.method + "String_Node_Str" + instruction.toString(context.constPool.getConstantPool()) + "String_Node_Str" + stmt.toString(true) + "String_Node_Str" + "String_Node_Str");
                    result = in;
                    break;
                }
                for (String methodName : receivers) {
                    doInvoke(methodName, stmt, context, input, interpreter, state, retval);
                }
            }
            break;
        case Constants.ARETURN:
        case Constants.RETURN:
            {
                filterSet(in, result, 0);
            }
            break;
        case Constants.IRETURN:
            {
                filterSet(in, result, 0);
                for (Location l : in.keySet()) {
                    if (l.stackLoc == context.stackPtr - 1) {
                        result.put(new Location(0), new ValueMapping(in.get(l), false));
                    }
                }
            }
            break;
        default:
            result = in;
            retval.put(context.callString, result);
            break;
    }
    context.stackPtr += instruction.produceStack(context.constPool) - instruction.consumeStack(context.constPool);
    return retval;
}

Output:
                 } else {
-                    for (Iterator<String> i = receivers.iterator(); i.hasNext(); ) {
-                        String fieldName = i.next();
+                    for (String fieldName : receivers) {
                         String f = fieldName.substring(fieldName.lastIndexOf("String_Node_Str"), fieldName.length());


Input:
private void rollbackJoinTableData(PersistenceDelegator delegator) {
    Map<String, JoinTableData> joinTableDataMap = getJoinTableDataMap();
    for (JoinTableData jtData : joinTableDataMap.values()) {
        if (jtData.isProcessed()) {
            EntityMetadata m = KunderaMetadataManager.getEntityMetadata(jtData.getEntityClass());
            Client client = delegator.getClient(m);
            if (OPERATION.INSERT.equals(jtData.getOperation())) {
                for (Object pk : jtData.getJoinTableRecords().keySet()) {
                    client.deleteByColumn(jtData.getSchemaName(), jtData.getJoinTableName(), m.getIdAttribute().getName(), pk);
                }
            } else if (OPERATION.DELETE.equals(jtData.getOperation())) {
                client.persistJoinTable(jtData);
            }
        }
    }
    joinTableDataMap.clear();
    joinTableDataMap = null;
    joinTableDataMap = new HashMap<String, JoinTableData>();
}

Output:
 private void rollbackJoinTableData(PersistenceDelegator delegator) {
-    Map<String, JoinTableData> joinTableDataMap = getJoinTableDataMap();
-    for (JoinTableData jtData : joinTableDataMap.values()) {
+    for (JoinTableData jtData : joinTableDataCollection) {
         if (jtData.isProcessed()) {


Input:
public boolean hasNextChild() {
    if (children == null) {
        return false;
    }
    if (currentChild < children.size()) {
        return true;
    }
    if (needRowGroups) {
        if (endOfGroups) {
            return false;
        }
        try {
            while (!endOfGroups) {
                int endingGroupIndex = GroupUtil.getEndingGroupLevel(rowCursor, groupCursors);
                if (endingGroupIndex <= 0) {
                    currentChild = 0;
                    children = new ArrayList();
                    if (crosstabItem.getGrandTotal(ROW_AXIS_TYPE) != null && (measureCount > 0 || !IColumnWalker.IGNORE_TOTAL_COLUMN_WITHOUT_MEASURE)) {
                        CrosstabFooterExecutor totalExecutor = new CrosstabFooterExecutor(this);
                        children.add(totalExecutor);
                    }
                    endOfGroups = true;
                    return currentChild < children.size();
                }
                if (rowCursor.next()) {
                    collectExecutable();
                    return currentChild < children.size();
                }
            }
        } catch (OLAPException e) {
            logger.log(Level.SEVERE, Messages.getString("String_Node_Str"), e);
        }
    }
    return false;
}

Output:
                     children = new ArrayList();
-                    if (crosstabItem.getGrandTotal(ROW_AXIS_TYPE) != null && (measureCount > 0 || !IColumnWalker.IGNORE_TOTAL_COLUMN_WITHOUT_MEASURE)) {
+                    if (needRowGrandTotal(GRAND_TOTAL_LOCATION_AFTER)) {
                         CrosstabFooterExecutor totalExecutor = new CrosstabFooterExecutor(this);


Input:
protected void onAttach(View view) {
    super.onAttach(view);
    getActionBar().show();
    dispose(null);
    userEntity = userUtils.getCurrentUser();
    if ("String_Node_Str".equals(appPreferences.getProxyType()) || appPreferences.getProxyType() == null) {
        hideProxySettings();
    } else {
        showProxySettings();
    }
    if (appPreferences.getProxyCredentials()) {
        showProxyCredentials();
    } else {
        hideProxyCredentials();
    }
    if (userEntity != null) {
        baseUrlTextView.setText(userEntity.getBaseUrl());
        reauthorizeButton.setOnClickListener(view14 -> {
            reauthorizeButton.setEnabled(false);
            getParentController().getRouter().pushController(RouterTransaction.with(new WebViewLoginController(userEntity.getBaseUrl(), true)).pushChangeHandler(new VerticalChangeHandler()).popChangeHandler(new VerticalChangeHandler()));
            reauthorizeButton.setEnabled(true);
        });
        if (userEntity.getDisplayName() != null) {
            displayNameTextView.setText(userEntity.getDisplayName());
        }
        GlideUrl glideUrl = new GlideUrl(ApiHelper.getUrlForAvatarWithName(userEntity.getBaseUrl(), userEntity.getUsername()), new LazyHeaders.Builder().setHeader("String_Node_Str", "String_Node_Str").setHeader("String_Node_Str", ApiHelper.getUserAgent()).build());
        GlideApp.with(NextcloudTalkApplication.getSharedApplication().getApplicationContext()).load(glideUrl).centerInside().apply(RequestOptions.bitmapTransform(new CircleCrop())).into(avatarImageView);
        profileQueryDisposable = ncApi.getUserProfile(ApiHelper.getCredentials(userEntity.getUsername(), userEntity.getToken()), ApiHelper.getUrlForUserProfile(userEntity.getBaseUrl())).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(userProfileOverall -> {
            String displayName = null;
            if (!TextUtils.isEmpty(userProfileOverall.getOcs().getData().getDisplayName())) {
                displayName = userProfileOverall.getOcs().getData().getDisplayName();
            } else if (!TextUtils.isEmpty(userProfileOverall.getOcs().getData().getDisplayNameAlt())) {
                displayName = userProfileOverall.getOcs().getData().getDisplayNameAlt();
            }
            if (!TextUtils.isEmpty(displayName) && !displayName.equals(userEntity.getDisplayName())) {
                dbQueryDisposable = userUtils.createOrUpdateUser(userEntity.getUsername(), userEntity.getToken(), userEntity.getBaseUrl(), displayName, null, true).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(userEntityResult -> {
                    displayNameTextView.setText(userEntityResult.getDisplayName());
                }, throwable -> {
                    dispose(dbQueryDisposable);
                }, () -> dispose(dbQueryDisposable));
            }
        }, throwable -> {
            dispose(profileQueryDisposable);
        }, () -> dispose(profileQueryDisposable));
        removeAccountButton.setEnabled(true);
        removeAccountButton.setOnClickListener(view1 -> {
            removeAccountButton.setEnabled(false);
            cookieManager.getCookieStore().removeAll();
            boolean otherUserExists = userUtils.scheduleUserForDeletionWithId(userEntity.getId());
            new JobRequest.Builder(AccountRemovalJob.TAG).setUpdateCurrent(true).startNow().build().schedule();
            if (otherUserExists && getView() != null) {
                onViewBound(getView());
                onAttach(getView());
            } else if (!otherUserExists) {
                if (getParentController() == null || getParentController().getRouter() == null) {
                    if (getActivity() != null) {
                        getActivity().finish();
                    }
                } else {
                    getParentController().getRouter().setRoot(RouterTransaction.with(new ServerSelectionController()).pushChangeHandler(new VerticalChangeHandler()).popChangeHandler(new VerticalChangeHandler()));
                }
            }
        });
    }
    if (userUtils.getUsers().size() <= 1) {
        switchAccountButton.setVisibility(View.GONE);
    } else {
        switchAccountButton.setEnabled(true);
    }
    addAccountButton.setEnabled(true);
    if (ErrorMessageHolder.getInstance().getMessageType() != null) {
        switch(ErrorMessageHolder.getInstance().getMessageType()) {
            case ACCOUNT_UPDATED_NOT_ADDED:
                messageText.setTextColor(getResources().getColor(R.color.colorPrimary));
                messageText.setText(getResources().getString(R.string.nc_settings_account_updated));
                messageView.setVisibility(View.VISIBLE);
                break;
            case WRONG_ACCOUNT:
                messageText.setTextColor(getResources().getColor(R.color.nc_darkRed));
                messageText.setText(getResources().getString(R.string.nc_settings_wrong_account));
                messageView.setVisibility(View.VISIBLE);
                break;
            case SERVER_WITHOUT_TALK:
                messageText.setTextColor(getResources().getColor(R.color.nc_darkRed));
                messageText.setText(getResources().getString(R.string.nc_settings_wrong_account));
                messageView.setVisibility(View.VISIBLE);
            case ACCOUNT_WAS_IMPORTED:
                messageText.setTextColor(getResources().getColor(R.color.colorPrimary));
                messageText.setText(getResources().getString(R.string.nc_Server_account_imported));
                messageView.setVisibility(View.VISIBLE);
                break;
            case FAILED_TO_IMPORT_ACCOUNT:
                messageText.setTextColor(getResources().getColor(R.color.nc_darkRed));
                messageText.setText(getResources().getString(R.string.nc_server_failed_to_import_account));
                messageView.setVisibility(View.VISIBLE);
                break;
            default:
                messageView.setVisibility(View.GONE);
                break;
        }
        ErrorMessageHolder.getInstance().setMessageType(null);
        messageView.animate().translationY(0).alpha(0.0f).setDuration(2500).setStartDelay(5000).setListener(new AnimatorListenerAdapter() {
            public void onAnimationEnd(Animator animation) {
                super.onAnimationEnd(animation);
                if (messageView != null) {
                    messageView.setVisibility(View.GONE);
                }
            }
        });
    } else {
        if (messageView != null) {
            messageView.setVisibility(View.GONE);
        }
    }
}

Output:
         }
-        GlideUrl glideUrl = new GlideUrl(ApiHelper.getUrlForAvatarWithName(userEntity.getBaseUrl(), userEntity.getUsername()), new LazyHeaders.Builder().setHeader("String_Node_Str", "String_Node_Str").setHeader("String_Node_Str", ApiHelper.getUserAgent()).build());
-        GlideApp.with(NextcloudTalkApplication.getSharedApplication().getApplicationContext()).load(glideUrl).centerInside().apply(RequestOptions.bitmapTransform(new CircleCrop())).into(avatarImageView);
+        loadAvatarImage();
         profileQueryDisposable = ncApi.getUserProfile(ApiHelper.getCredentials(userEntity.getUsername(), userEntity.getToken()), ApiHelper.getUrlForUserProfile(userEntity.getBaseUrl())).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(userProfileOverall -> {


Input:
public static Report lastReport(User user, String id, String resourceOrSip, String acceptFormat) throws AuthorizationDeniedException, GenericException, NotFoundException, RequestNotValidException {
    final ControllerAssistant controllerAssistant = new ControllerAssistant() {
    };
    BrowserHelper.validateListingParams(acceptFormat);
    controllerAssistant.checkRoles(user);
    String start = "String_Node_Str";
    String limit = "String_Node_Str";
    Reports reportList;
    if (id == null || resourceOrSip == null) {
        reportList = BrowserHelper.listReports(start, limit);
    } else {
        if (RodaConstants.API_GET_REPORTS_ID_OBJECT_SIP.equals(resourceOrSip)) {
            reportList = BrowserHelper.listTransferredResourcesReportsWithSIP(id, start, limit);
        } else {
            reportList = BrowserHelper.listTransferredResourcesReports(id, start, limit);
        }
    }
    controllerAssistant.registerAction(user, id, LOG_ENTRY_STATE.SUCCESS, RodaConstants.API_QUERY_PARAM_ID, id, RodaConstants.API_GET_REPORTS_ID_OBJECT, resourceOrSip, RodaConstants.API_QUERY_KEY_START, start, RodaConstants.API_QUERY_KEY_LIMIT, limit);
    return reportList.getReports().get(0);
}

Output:
     controllerAssistant.registerAction(user, id, LOG_ENTRY_STATE.SUCCESS, RodaConstants.API_QUERY_PARAM_ID, id, RodaConstants.API_GET_REPORTS_ID_OBJECT, resourceOrSip, RodaConstants.API_QUERY_KEY_START, start, RodaConstants.API_QUERY_KEY_LIMIT, limit);
-    return reportList.getReports().get(0);
+    if (reportList.getReports().isEmpty()) {
+        throw new RODAException();
+    } else {
+        return reportList.getReports().get(0);
+    }
 }


Input:
public void no_set_can_be_generated_from_current_stage_maximum_generation() {
    frequentSupportMap = new TreeMap<BinaryItemSet, Integer>();
    char vector = 57344;
    frequentSupportMap.put(new BinaryItemSet(new char[] { vector }), 1);
    Set<BinaryItemSet> result = engine.getCandidateSets(frequentSupportMap, 1);
    Assert.assertTrue(expecetCandidates.equals(result));
}

Output:
     frequentSupportMap.put(new BinaryItemSet(new char[] { vector }), 1);
-    Set<BinaryItemSet> result = engine.getCandidateSets(frequentSupportMap, 1);
+    Set<BinaryItemSet> result = engine.getCandidateSets(frequentSupportMap.keySet(), 1);
     Assert.assertTrue(expecetCandidates.equals(result));


Input:
public void testFormattingTrue() throws Exception {
    formatTest(true, XML_HEADER + XML_BODY_FORMATTED);
}

Output:
 public void testFormattingTrue() throws Exception {
-    formatTest(true, XML_HEADER + XML_BODY_FORMATTED);
+    formatTest(true, XML_HEADER + CRLF + XML_BODY_FORMATTED);
 }


Input:
public void placeComponents(Composite parent) {
    Series series = seriesDefn.getDesignTimeSeries();
    linkSeries = new Link(parent, SWT.NONE);
    {
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        linkSeries.setLayoutData(gd);
        linkSeries.setText("String_Node_Str" + seriesName + "String_Node_Str");
        linkSeries.addSelectionListener(this);
    }
    List<String> keys = null;
    if (getContext().getUIServiceProvider() != null) {
        keys = getContext().getUIServiceProvider().getRegisteredKeys();
    }
    txtTitle = new ExternalizedTextEditorComposite(parent, SWT.BORDER | SWT.SINGLE, -1, -1, keys, getContext().getUIServiceProvider(), series.getSeriesIdentifier().toString());
    {
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        txtTitle.setLayoutData(gd);
        txtTitle.addListener(this);
    }
    cmbTypes = new Combo(parent, SWT.DROP_DOWN | SWT.READ_ONLY);
    {
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        cmbTypes.setLayoutData(gd);
        cmbTypes.addSelectionListener(this);
        if (iSeriesDefinitionIndex == 0) {
            cmbTypes.setEnabled(false);
        }
    }
    if (!series.getClass().isAssignableFrom(SeriesImpl.class)) {
        spnZOrder = new Spinner(parent, SWT.BORDER);
        {
            GridData gd = new GridData();
            gd.horizontalAlignment = SWT.CENTER;
            spnZOrder.setLayoutData(gd);
            spnZOrder.setMinimum(0);
            spnZOrder.setMaximum(10);
            if (getChart() instanceof ChartWithAxes && !(getContext().getChartType() instanceof BubbleChart)) {
                spnZOrder.setSelection(seriesDefn.getZOrder());
                spnZOrder.addSelectionListener(this);
            } else {
                spnZOrder.setEnabled(false);
            }
        }
        btnVisible = new Button(parent, SWT.CHECK);
        {
            GridData gd = new GridData();
            gd.horizontalAlignment = SWT.CENTER;
            btnVisible.setLayoutData(gd);
            btnVisible.setSelection(series.isVisible());
            btnVisible.addSelectionListener(this);
        }
        btnStack = new Button(parent, SWT.CHECK);
        {
            GridData gd = new GridData();
            gd.horizontalAlignment = SWT.CENTER;
            btnStack.setLayoutData(gd);
            btnStack.setEnabled(canStack && series.canBeStacked() && getChart().getDimension().getValue() != ChartDimension.THREE_DIMENSIONAL && !bStackedPercent);
            if (series.isStacked() && !canStack) {
                btnStack.setSelection(false);
                series.setStacked(false);
            } else {
                btnStack.setSelection(series.isStacked());
            }
            btnStack.addSelectionListener(this);
        }
        btnTranslucent = new Button(parent, SWT.CHECK);
        {
            GridData gd = new GridData();
            gd.horizontalAlignment = SWT.CENTER;
            btnTranslucent.setLayoutData(gd);
            btnTranslucent.setSelection(series.isTranslucent());
            btnTranslucent.addSelectionListener(this);
        }
        setTypeComboState();
        setStackedBoxState();
    } else {
        Label dummy = new Label(parent, SWT.CHECK);
        GridData gd = new GridData();
        gd.horizontalSpan = 4;
        dummy.setLayoutData(gd);
    }
    populateLists(seriesDefn.getDesignTimeSeries());
}

Output:
             spnZOrder.setMaximum(10);
-            if (getChart() instanceof ChartWithAxes && !(getContext().getChartType() instanceof BubbleChart)) {
+            if (getChart() instanceof ChartWithAxes && !(getContext().getChartType() instanceof BubbleChart) && getChart().getDimension() == ChartDimension.TWO_DIMENSIONAL_LITERAL) {
                 spnZOrder.setSelection(seriesDefn.getZOrder());


Input:
public static ComposeData buildDefault(Context context, Uri uri) {
    return new ComposeData(uri, context.getString(R.string.default_lgtm_text), 40, Color.BLACK);
}

Output:
 public static ComposeData buildDefault(Context context, Uri uri) {
-    return new ComposeData(uri, context.getString(R.string.default_lgtm_text), 40, Color.BLACK);
+    return new ComposeData(uri, context.getString(R.string.default_lgtm_text), 80, Color.BLACK);
 }


Input:
public void endTransactionAndNotify() {
    if (isInTransaction) {
        isInTransaction = false;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
            onChange(true);
        } else {
            synchronized (notificationUris) {
                for (Uri uri : notificationUris) {
                    onChange(true, uri);
                }
                notificationUris.clear();
            }
        }
    }
}

Output:
         isInTransaction = false;
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
             onChange(true);


Input:
public synchronized Count getMatchCount(NewsItem article, int numTokens, Hashtable matchCounts) {
    if (_log.isDebugEnabled())
        _log.debug("String_Node_Str" + _name);
    ArrayList<Category> matchedCats = new ArrayList<Category>();
    int matchCount = 0;
    if (isLeafCategory()) {
        if (_log.isDebugEnabled())
            _log.debug("String_Node_Str" + _name + "String_Node_Str" + _filter._ruleString + "String_Node_Str");
        matchCount = _filter.getMatchCount(article, numTokens, matchCounts);
        if ((matchCount >= Filter.MIN_REQD_MATCH_COUNT) || ((numTokens < 250) && (matchCount > 0) && (matchCount < Filter.MIN_REQD_MATCH_COUNT))) {
            if (containsArticle(article))
                return DEFAULT_COUNT;
            matchedCats.add(this);
        }
    } else {
        if (_log.isDebugEnabled())
            _log.debug("String_Node_Str" + _name + "String_Node_Str");
        for (Category subCat : _children) {
            Count subCatCount = subCat.getMatchCount(article, numTokens, matchCounts);
            if (subCatCount.value() > matchCount)
                matchCount = subCatCount.value();
            matchedCats.addAll(subCatCount.getMatchedCats());
        }
        if (_log.isDebugEnabled())
            _log.debug("String_Node_Str" + _name + "String_Node_Str");
    }
    if (!matchedCats.isEmpty()) {
        _outputFeed.addNewsItem(article, matchedCats);
        _db.addNewsItem(article, this, matchCount);
        _lastUpdateTime = new Date();
        if (_log.isDebugEnabled())
            _log.debug("String_Node_Str" + _name);
    }
    final Count retVal = new Count(matchCount, matchedCats);
    matchCounts.put("String_Node_Str" + _name + "String_Node_Str", retVal);
    for (Category subCat : _children) matchCounts.remove("String_Node_Str" + subCat._name + "String_Node_Str");
    return retVal;
}

Output:
         if ((matchCount >= Filter.MIN_REQD_MATCH_COUNT) || ((numTokens < 250) && (matchCount > 0) && (matchCount < Filter.MIN_REQD_MATCH_COUNT))) {
-            if (containsArticle(article))
-                return DEFAULT_COUNT;
-            matchedCats.add(this);
+            if (!containsArticle(article))
+                matchedCats.add(this);
         }


Input:
private void onUserUnlocked(int userId) {
    AccountManagerService.getSingleton().validateAccounts(userId);
    mSyncAdapters.invalidateCache(userId);
    updateRunningAccounts(false);
    synchronized (mSyncQueue) {
        mSyncQueue.addPendingOperations(userId);
    }
    final Account[] accounts = AccountManagerService.getSingleton().getAccounts(userId, mContext.getOpPackageName());
    for (Account account : accounts) {
        scheduleSync(account, userId, SyncOperation.REASON_USER_START, null, null, 0, 0, true);
    }
    sendCheckAlarmsMessage();
}

Output:
     mSyncAdapters.invalidateCache(userId);
-    updateRunningAccounts(false);
+    updateRunningAccounts();
     synchronized (mSyncQueue) {


Input:
public Vector<DownloadLink> getSelectedObjects() {
    int[] rows = table.getSelectedRows();
    Vector<DownloadLink> linksSelected = new Vector<DownloadLink>();
    for (int i = 0; i < rows.length; i++) {
        linksSelected.add(allLinks.get(rows[i]));
    }
    return linksSelected;
}

Output:
     for (int i = 0; i < rows.length; i++) {
-        linksSelected.add(allLinks.get(rows[i]));
+        if (rows[i] < als)
+            linksSelected.add(allLinks.get(rows[i]));
     }


Input:
public boolean bucket(NodeRef leftParent, NodeRef rightParent, BucketIndex bucketIndex, Bucket left, Bucket right) {
    if (left == null || right == null) {
        Bucket bucket = left == null ? right : left;
        addTreeFeatures(bucket.getObjectId(), left != null, right != null);
        return false;
    }
    return true;
}

Output:
 public boolean bucket(NodeRef leftParent, NodeRef rightParent, BucketIndex bucketIndex, Bucket left, Bucket right) {
-    if (left == null || right == null) {
+    if (bucketIndex.left().isEmpty() || bucketIndex.right().isEmpty()) {
         Bucket bucket = left == null ? right : left;


Input:
public void addURL(URL url) {
    if (this.urls.contains(url))
        return;
    this.urls.add(url);
    this.loaders.add(createLoader(url));
}

Output:
 public void addURL(URL url) {
-    if (this.urls.contains(url))
+    if (url == null || this.urls.contains(url))
         return;


Input:
public double getAltitude() {
    boolean Mbit = (altitude_code & 0x40) != 0;
    boolean Qbit = (altitude_code & 0x10) != 0;
    int N;
    if (!Mbit && Qbit) {
        N = (altitude_code & 0xF) | ((altitude_code & 0x20) >>> 1) | ((altitude_code & 0x1F80) >>> 2);
        return (25 * N - 1000) * 0.3048;
    } else {
        int C1 = (0x1000 & altitude_code) >>> 12;
        int A1 = (0x800 & altitude_code) >>> 11;
        int C2 = (0x400 & altitude_code) >>> 10;
        int A2 = (0x200 & altitude_code) >>> 9;
        int C4 = (0x100 & altitude_code) >>> 8;
        int A4 = (0x080 & altitude_code) >>> 7;
        int B1 = (0x020 & altitude_code) >>> 5;
        int B2 = (0x008 & altitude_code) >>> 3;
        int D2 = (0x004 & altitude_code) >>> 2;
        int B4 = (0x002 & altitude_code) >>> 1;
        int D4 = (0x001 & altitude_code);
        int N500 = grayToBin(D2 << 7 | D4 << 6 | A1 << 5 | A2 << 4 | A4 << 3 | B1 << 2 | B2 << 1 | B4, 8);
        int N100 = grayToBin(C1 << 2 | C2 << 1 | C4, 3) - 1;
        if (N100 == 6)
            N100 = 4;
        if (N500 % 2 != 0)
            N100 = 4 - N100;
        return (-1200 + N500 * 500 + N100 * 100) * 0.3048;
    }
}

Output:
     boolean Mbit = (altitude_code & 0x40) != 0;
-    boolean Qbit = (altitude_code & 0x10) != 0;
-    int N;
-    if (!Mbit && Qbit) {
-        N = (altitude_code & 0xF) | ((altitude_code & 0x20) >>> 1) | ((altitude_code & 0x1F80) >>> 2);
-        return (25 * N - 1000) * 0.3048;
-    } else {
-        int C1 = (0x1000 & altitude_code) >>> 12;
-        int A1 = (0x800 & altitude_code) >>> 11;
-        int C2 = (0x400 & altitude_code) >>> 10;
-        int A2 = (0x200 & altitude_code) >>> 9;
-        int C4 = (0x100 & altitude_code) >>> 8;
-        int A4 = (0x080 & altitude_code) >>> 7;
-        int B1 = (0x020 & altitude_code) >>> 5;
-        int B2 = (0x008 & altitude_code) >>> 3;
-        int D2 = (0x004 & altitude_code) >>> 2;
-        int B4 = (0x002 & altitude_code) >>> 1;
-        int D4 = (0x001 & altitude_code);
-        int N500 = grayToBin(D2 << 7 | D4 << 6 | A1 << 5 | A2 << 4 | A4 << 3 | B1 << 2 | B2 << 1 | B4, 8);
-        int N100 = grayToBin(C1 << 2 | C2 << 1 | C4, 3) - 1;
-        if (N100 == 6)
-            N100 = 4;
-        if (N500 % 2 != 0)
-            N100 = 4 - N100;
-        return (-1200 + N500 * 500 + N100 * 100) * 0.3048;
-    }
+    if (!Mbit) {
+        boolean Qbit = (altitude_code & 0x10) != 0;
+        if (Qbit) {
+            int N = (altitude_code & 0x0F) | ((altitude_code & 0x20) >>> 1) | ((altitude_code & 0x1F80) >>> 2);
+            return (25 * N - 1000) * 0.3048;
+        } else {
+            int C1 = (0x1000 & altitude_code) >>> 12;
+            int A1 = (0x0800 & altitude_code) >>> 11;
+            int C2 = (0x0400 & altitude_code) >>> 10;
+            int A2 = (0x0200 & altitude_code) >>> 9;
+            int C4 = (0x0100 & altitude_code) >>> 8;
+            int A4 = (0x0080 & altitude_code) >>> 7;
+            int B1 = (0x0020 & altitude_code) >>> 5;
+            int B2 = (0x0008 & altitude_code) >>> 3;
+            int D2 = (0x0004 & altitude_code) >>> 2;
+            int B4 = (0x0002 & altitude_code) >>> 1;
+            int D4 = (0x0001 & altitude_code);
+            int N500 = grayToBin(D2 << 7 | D4 << 6 | A1 << 5 | A2 << 4 | A4 << 3 | B1 << 2 | B2 << 1 | B4, 8);
+            int N100 = grayToBin(C1 << 2 | C2 << 1 | C4, 3) - 1;
+            if (N100 == 6)
+                N100 = 4;
+            if (N500 % 2 != 0)
+                N100 = 4 - N100;
+            return (-1200 + N500 * 500 + N100 * 100) * 0.3048;
+        }
+    } else
+        return null;
 }


Input:
public Set<Comment> find(Map<Enum, Object> fieldsMap) throws IOException {
    return super.realFind(fieldsMap);
}

Output:
 public Set<Comment> find(Map<Enum, Object> fieldsMap) throws IOException {
-    return super.realFind(fieldsMap);
+    Set<Comment> foundSet = new HashSet<Comment>();
+    EnumSet<Comment._Fields> dateTimeFields = EnumSet.of(Comment._Fields.created_at);
+    if (fieldsMap == null || fieldsMap.isEmpty()) {
+        return foundSet;
+    }
+    StringBuilder statementString = new StringBuilder();
+    statementString.append("String_Node_Str");
+    statementString.append("String_Node_Str");
+    statementString.append("String_Node_Str");
+    Iterator<Map.Entry<Enum, Object>> iter = fieldsMap.entrySet().iterator();
+    while (iter.hasNext()) {
+        Map.Entry<Enum, Object> entry = iter.next();
+        Enum field = entry.getKey();
+        String queryValue = entry.getValue().toString();
+        if (dateTimeFields.contains(field)) {
+            queryValue = new Timestamp((Long) entry.getValue()).toString();
+        }
+        statementString.append(field + "String_Node_Str" + queryValue + "String_Node_Str");
+        if (iter.hasNext()) {
+            statementString.append("String_Node_Str");
+        }
+    }
+    statementString.append("String_Node_Str");
+    executeQuery(foundSet, statementString);
+    return foundSet;
 }


Input:
public void loadChatRoom(ChatRoom chatRoom) {
    currentChatTransport = new ConferenceChatTransport(this, chatRoomWrapper.getChatRoom());
    chatTransports.clear();
    chatTransports.add(currentChatTransport);
    sessionRenderer.removeAllChatContacts();
    for (ChatRoomMember member : chatRoom.getMembers()) {
        sessionRenderer.addChatContact(new ConferenceChatContact(member));
    }
    chatRoom.addPropertyChangeListener(this);
    chatRoom.addMemberPresenceListener(this);
    sessionRenderer.setChatSubject(chatRoom.getSubject());
}

Output:
     chatTransports.add(currentChatTransport);
-    sessionRenderer.removeAllChatContacts();
-    for (ChatRoomMember member : chatRoom.getMembers()) {
-        sessionRenderer.addChatContact(new ConferenceChatContact(member));
+    synchronized (this.chatParticipants) {
+        sessionRenderer.removeAllChatContacts();
+        this.chatParticipants.clear();
+        for (ChatRoomMember member : chatRoom.getMembers()) {
+            ConferenceChatContact contact = new ConferenceChatContact(member);
+            chatParticipants.add(contact);
+            sessionRenderer.addChatContact(contact);
+        }
     }


Input:
public List<Row> process(RowScanner rowScanner, CustomColumnFactory customColumnFactory, ColumnFamilyStore table, RowIndex currentIndex) throws Exception {
    Options options = rowScanner.getOptions();
    Group group = new Group(options, aggregates, groupBy, groupByExpressions);
    if (aggregates.length == 1 && !aggregates[0].distinct && groupBy == null) {
        Count count = new Count(aggregates[0], null, false);
        count.count = rowScanner.getCollector().docs().size();
        group.groups.put(new Tuple(Collections.EMPTY_MAP, Collections.EMPTY_MAP, simpleExpressions), count);
        Row row = customColumnFactory.getRowWithMetaColumn(table, currentIndex, group.toByteBuffer());
        return Collections.singletonList(row);
    }
    Tuple tuple = new Tuple(positions, allValidators, simpleExpressions);
    if (rowScanner.getCollector().canByPassRowFetch()) {
        Iterator<IndexEntryCollector.IndexEntry> indexIterator = rowScanner.getCollector().docs().iterator();
        while (indexIterator.hasNext()) {
            IndexEntryCollector.IndexEntry indexEntry = indexIterator.next();
            tuple.load(indexEntry);
            group.addTuple(tuple);
        }
    } else {
        if (chunkSize == 1) {
            while (rowScanner.hasNext()) {
                Row row = rowScanner.next();
                tuple.load(row, table);
                group.addTuple(tuple);
            }
        } else {
            List<Row> rows;
            while (rowScanner.hasNext()) {
                rows = new ArrayList<>(chunkSize);
                for (int i = 0; i < chunkSize; i++) {
                    if (!rowScanner.hasNext())
                        break;
                    rows.add(rowScanner.next());
                }
                for (Row row : rows) {
                    tuple.load(row, table);
                    group.addTuple(tuple);
                }
            }
        }
    }
    Utils.SimpleTimer timer3 = Utils.getStartedTimer(SearchSupport.logger);
    ByteBuffer groupBuffer = group.toByteBuffer();
    timer3.endLogTime("String_Node_Str" + group.groups.size() + "String_Node_Str");
    Row row = customColumnFactory.getRowWithMetaColumn(table, currentIndex, groupBuffer);
    return Collections.singletonList(row);
}

Output:
     Group group = new Group(options, aggregates, groupBy, groupByExpressions);
-    if (aggregates.length == 1 && !aggregates[0].distinct && groupBy == null) {
+    if (aggregates.length == 1 && !aggregates[0].distinct && "String_Node_Str".equalsIgnoreCase(aggregates[0].getType()) && groupBy == null) {
         Count count = new Count(aggregates[0], null, false);


Input:
protected String getApplicationDomain() {
    return applicationDomain != null ? applicationDomain : mPiwik.getApplicationDomain();
}

Output:
 protected String getApplicationDomain() {
-    return applicationDomain != null ? applicationDomain : mPiwik.getApplicationDomain();
+    return mApplicationDomain != null ? mApplicationDomain : mPiwik.getApplicationDomain();
 }


Input:
public void validate(H2ConnectionSettings settings) throws ProtocolException, FrameSizeException {
    if (streamId == 0) {
        throw new ProtocolException("String_Node_Str");
    } else if (this.getPayloadLength() <= 0) {
        throw new ProtocolException("String_Node_Str");
    } else if (this.getPayloadLength() > settings.maxFrameSize) {
        throw new FrameSizeException("String_Node_Str");
    } else if (this.paddingLength >= this.payloadLength) {
        throw new ProtocolException("String_Node_Str");
    } else if (this.streamId == this.streamDependency) {
        throw new ProtocolException("String_Node_Str");
    } else if (this.paddingLength < 0) {
        throw new ProtocolException("String_Node_Str");
    }
}

Output:
     } else if (this.getPayloadLength() <= 0) {
-        throw new ProtocolException("String_Node_Str");
+        throw new CompressionException("String_Node_Str");
     } else if (this.getPayloadLength() > settings.maxFrameSize) {


Input:
private UserSession getUserSessionForGui(Long identityKey) {
    UserSession identitySession = null;
    if (identityKey != null) {
        identitySession = authUserSessions.stream().filter(userSession -> {
            Identity identity = userSession.getIdentity();
            if (identity != null && identityKey.equals(identity.getKey()) && userSession.getSessionInfo() != null && !userSession.getSessionInfo().isWebDAV() && !userSession.getSessionInfo().isREST()) {
                return true;
            }
            return false;
        }).findFirst().get();
    }
    return identitySession;
}

Output:
     if (identityKey != null) {
-        identitySession = authUserSessions.stream().filter(userSession -> {
+        Optional<UserSession> optionalSession = authUserSessions.stream().filter(userSession -> {
             Identity identity = userSession.getIdentity();


Input:
public boolean handle(World world, BlockPos pos, EnumFacing direction, ItemStack stack, EntityPlayer player, IStripesActivator activator) {
    AxisAlignedBB box = new AxisAlignedBB(pos, x + 1, y + 1, z + 1);
    List entities = world.getEntitiesWithinAABBExcludingEntity(null, box);
    if (entities.size() <= 0) {
        return false;
    }
    List<EntityMinecart> minecarts = new LinkedList<EntityMinecart>();
    for (Object entityObj : entities) {
        if (entityObj instanceof EntityMinecart) {
            minecarts.add((EntityMinecart) entityObj);
        }
    }
    if (minecarts.size() > 0) {
        Collections.shuffle(minecarts);
        EntityMinecart cart = minecarts.get(0);
        if (cart instanceof EntityMinecartContainer) {
            EntityMinecartContainer container = (EntityMinecartContainer) cart;
            for (int i = 0; i < container.getSizeInventory(); i++) {
                ItemStack s = container.getStackInSlot(i);
                if (s != null) {
                    container.setInventorySlotContents(i, null);
                    if (container.getStackInSlot(i) == null) {
                        activator.sendItem(s, direction.getOpposite());
                    }
                }
            }
        }
        cart.setDead();
        activator.sendItem(cart.getCartItem(), direction.getOpposite());
        return true;
    }
    return false;
}

Output:
 public boolean handle(World world, BlockPos pos, EnumFacing direction, ItemStack stack, EntityPlayer player, IStripesActivator activator) {
-    AxisAlignedBB box = new AxisAlignedBB(pos, x + 1, y + 1, z + 1);
+    AxisAlignedBB box = new AxisAlignedBB(pos, pos.add(1, 1, 1));
     List entities = world.getEntitiesWithinAABBExcludingEntity(null, box);


Input:
private void switchToList() {
    createLabel(valueArea, LABEL_VALUES, maxStrLengthProperty);
    Composite tableArea = new Composite(valueArea, SWT.NONE);
    tableArea.setLayout(UIUtil.createGridLayoutWithoutMargin());
    tableArea.setLayoutData(new GridData(GridData.FILL_BOTH));
    Table table = new Table(tableArea, SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER);
    table.setLayoutData(new GridData(GridData.FILL_BOTH));
    table.setLinesVisible(true);
    table.setHeaderVisible(true);
    table.addKeyListener(new KeyAdapter() {
        public void keyReleased(KeyEvent e) {
            if (e.keyCode == SWT.DEL) {
                deleteRow();
            }
        }
    });
    String[] columns;
    int[] columnWidth;
    CellEditor[] cellEditors;
    columns = new String[] { null, COLUMN_IS_DEFAULT, COLUMN_VALUE, COLUMN_DISPLAY_TEXT };
    columnWidth = new int[] { 20, 70, 145, 145 };
    cellEditors = new CellEditor[] { null, null, new TextCellEditor(table), new TextCellEditor(table) };
    for (int i = 0; i < columns.length; i++) {
        TableColumn column = new TableColumn(table, SWT.LEFT);
        column.setResizable(columns[i] != null && !COLUMN_IS_DEFAULT.equals(columns[i]));
        if (columns[i] != null) {
            column.setText(columns[i]);
        }
        column.setWidth(columnWidth[i]);
    }
    valueTable = new TableViewer(table);
    valueTable.setCellEditors(cellEditors);
    valueTable.setColumnProperties(columns);
    valueTable.setContentProvider(contentProvider);
    valueTable.setLabelProvider(labelProvider);
    valueTable.setCellModifier(cellModifier);
    valueTable.setInput(choiceList);
    valueTable.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent event) {
            updateTableButtons();
        }
    });
    Composite buttonBar = new Composite(tableArea, SWT.NONE);
    buttonBar.setLayout(UIUtil.createGridLayoutWithoutMargin(4, false));
    buttonBar.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    importValue = new Button(buttonBar, SWT.PUSH);
    importValue.setText(BUTTON_LABEL_IMPORT);
    setButtonLayoutData(importValue);
    importValue.setEnabled(!inputParameter.getModuleHandle().getVisibleDataSets().isEmpty());
    importValue.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            String type = getSelectedDataType();
            ImportValueDialog dialog = new ImportValueDialog(type);
            if (dialog.open() == OK) {
                String[] importValues = (String[]) dialog.getResult();
                for (int i = 0; i < importValues.length; i++) {
                    if (!containValue(null, importValues[i], COLUMN_VALUE)) {
                        SelectionChoice choice = StructureFactory.createSelectionChoice();
                        choice.setValue(importValues[i]);
                        choiceList.add(choice);
                    }
                }
                refreshValueTable();
            }
        }
    });
    changeDefault = new Button(buttonBar, SWT.TOGGLE);
    changeDefault.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            SelectionChoice choice = (SelectionChoice) ((IStructuredSelection) valueTable.getSelection()).getFirstElement();
            if (isDefaultChoice(choice)) {
                defaultValue = null;
            } else {
                defaultValue = choice.getValue();
            }
            refreshValueTable();
            updateMessageLine();
            updateButtons();
        }
    });
    delete = new Button(buttonBar, SWT.PUSH);
    delete.setText(BUTTON_LABEL_DELETE);
    setButtonLayoutData(delete);
    delete.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            deleteRow();
        }
    });
    createPromptLine(tableArea);
    updateTableButtons();
}

Output:
 private void switchToList() {
-    createLabel(valueArea, LABEL_VALUES, maxStrLengthProperty);
+    createLabel(valueArea, LABEL_VALUES);
     Composite tableArea = new Composite(valueArea, SWT.NONE);


Input:
public void addMenuEntry(final String menuText, final InputStream imageStream, final SystemTrayMenuAction callback) {
    if (imageStream == null) {
        addMenuEntry_(menuText, null, callback);
    } else {
        addMenuEntry_(menuText, ImageUtils.resizeAndCache(ImageUtils.SIZE, imageStream), callback);
    }
}

Output:
     } else {
-        addMenuEntry_(menuText, ImageUtils.resizeAndCache(ImageUtils.SIZE, imageStream), callback);
+        addMenuEntry_(menuText, ImageUtils.resizeAndCache(ImageUtils.ENTRY_SIZE, imageStream), callback);
     }


Input:
public static boolean addFlag(final AbstractFlag af) {
    PlotSquared.log(C.PREFIX.s() + "String_Node_Str" + af);
    af.getKey();
    if (PlotSquared.getAllPlotsRaw() != null) {
        for (final Plot plot : PlotSquared.getPlots()) {
            for (final Flag flag : plot.settings.flags) {
                if (flag.getAbstractFlag().getKey().equals(af.getKey())) {
                    flag.setKey(af);
                }
            }
        }
    }
    return (getFlag(af.getKey()) == null) && flags.add(af);
}

Output:
     PlotSquared.log(C.PREFIX.s() + "String_Node_Str" + af);
-    af.getKey();
+    for (PlotWorld plotworld : PlotSquared.getPlotWorldObjects()) {
+        for (final Flag flag : plotworld.DEFAULT_FLAGS) {
+            if (flag.getAbstractFlag().getKey().equals(af.getKey())) {
+                flag.setKey(af);
+            }
+        }
+    }
     if (PlotSquared.getAllPlotsRaw() != null) {


Input:
protected void drawDocumentBackground() throws IOException {
    IStyle style = previousPage.getComputedStyle();
    String backgroundColor = style.getBackgroundColor();
    String backgroundImageUrl = org.eclipse.birt.report.engine.layout.emitter.EmitterUtil.getBackgroundImageUrl(style, reportContent.getDesign().getReportDesign());
    wordWriter.drawDocumentBackground(backgroundColor, backgroundImageUrl);
}

Output:
     String backgroundColor = style.getBackgroundColor();
-    String backgroundImageUrl = org.eclipse.birt.report.engine.layout.emitter.EmitterUtil.getBackgroundImageUrl(style, reportContent.getDesign().getReportDesign());
+    String backgroundImageUrl = EmitterUtil.getBackgroundImageUrl(style, reportContent.getDesign().getReportDesign());
     wordWriter.drawDocumentBackground(backgroundColor, backgroundImageUrl);


Input:
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    RangerSecurityContext context = RangerContextHolder.getSecurityContext();
    UserSessionBase session = context != null ? context.getUserSession() : null;
    ssoEnabled = session != null ? session.isSSOEnabled() : PropertiesUtil.getBooleanProperty("String_Node_Str", false);
    String userAgent = ((HttpServletRequest) servletRequest).getHeader("String_Node_Str");
    if (((HttpServletRequest) servletRequest).getSession() != null) {
        if (((HttpServletRequest) servletRequest).getSession().getAttribute("String_Node_Str") != null) {
            ssoEnabled = false;
            servletRequest.setAttribute("String_Node_Str", false);
            filterChain.doFilter(servletRequest, servletResponse);
            return;
        }
    }
    if (ssoEnabled && !((HttpServletRequest) servletRequest).getRequestURI().contains(LOCAL_LOGIN_URL) && isWebUserAgent(userAgent)) {
        if (jwtProperties != null && !isAuthenticated()) {
            HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
            HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse;
            String serializedJWT = getJWTFromCookie(httpServletRequest);
            if (serializedJWT != null) {
                SignedJWT jwtToken = null;
                try {
                    jwtToken = SignedJWT.parse(serializedJWT);
                    boolean valid = validateToken(jwtToken);
                    if (valid) {
                        String userName = jwtToken.getJWTClaimsSet().getSubject();
                        LOG.info("String_Node_Str" + userName);
                        String rangerLdapDefaultRole = PropertiesUtil.getProperty("String_Node_Str", "String_Node_Str");
                        if (userName != null && !userName.trim().isEmpty()) {
                            final List<GrantedAuthority> grantedAuths = new ArrayList<>();
                            grantedAuths.add(new SimpleGrantedAuthority(rangerLdapDefaultRole));
                            final UserDetails principal = new User(userName, "String_Node_Str", grantedAuths);
                            final Authentication finalAuthentication = new UsernamePasswordAuthenticationToken(principal, "String_Node_Str", grantedAuths);
                            WebAuthenticationDetails webDetails = new WebAuthenticationDetails(httpServletRequest);
                            ((AbstractAuthenticationToken) finalAuthentication).setDetails(webDetails);
                            RangerAuthenticationProvider authenticationProvider = new RangerAuthenticationProvider();
                            authenticationProvider.setSsoEnabled(ssoEnabled);
                            final Authentication authentication = authenticationProvider.authenticate(finalAuthentication);
                            SecurityContextHolder.getContext().setAuthentication(authentication);
                        }
                        filterChain.doFilter(servletRequest, httpServletResponse);
                    } else {
                        String ssourl = constructLoginURL(httpServletRequest);
                        if (LOG.isDebugEnabled())
                            LOG.debug("String_Node_Str" + ssourl);
                        httpServletResponse.sendRedirect(ssourl);
                    }
                } catch (ParseException e) {
                    LOG.warn("String_Node_Str", e);
                }
            } else {
                String ssourl = constructLoginURL(httpServletRequest);
                if (LOG.isDebugEnabled())
                    LOG.debug("String_Node_Str" + ssourl);
                httpServletResponse.sendRedirect(ssourl);
            }
        } else {
            filterChain.doFilter(servletRequest, servletResponse);
        }
    } else if (ssoEnabled && ((HttpServletRequest) servletRequest).getRequestURI().contains(LOCAL_LOGIN_URL) && isWebUserAgent(userAgent) && isAuthenticated()) {
        String url = ((HttpServletRequest) servletRequest).getRequestURI().replace(LOCAL_LOGIN_URL + "String_Node_Str", "String_Node_Str");
        url = url.replace(LOCAL_LOGIN_URL, "String_Node_Str");
        LOG.warn("String_Node_Str");
        ((HttpServletResponse) servletResponse).sendRedirect(url);
    } else {
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

Output:
     ssoEnabled = session != null ? session.isSSOEnabled() : PropertiesUtil.getBooleanProperty("String_Node_Str", false);
-    String userAgent = ((HttpServletRequest) servletRequest).getHeader("String_Node_Str");
-    if (((HttpServletRequest) servletRequest).getSession() != null) {
-        if (((HttpServletRequest) servletRequest).getSession().getAttribute("String_Node_Str") != null) {
+    String userAgent = httpRequest.getHeader("String_Node_Str");
+    if (httpRequest.getSession() != null) {
+        if (httpRequest.getSession().getAttribute("String_Node_Str") != null) {
             ssoEnabled = false;


Input:
public boolean findExistClientByName(String clientName) {
    Search search = new Search();
    search.addFilterEqual("String_Node_Str", clientName);
    List<ClientPo> clientPoList = clientDao.search(search);
    if (clientPoList != null && clientPoList.size() > 0) {
        return true;
    } else {
        return false;
    }
}

Output:
     search.addFilterEqual("String_Node_Str", clientName);
-    List<ClientPo> clientPoList = clientDao.search(search);
-    if (clientPoList != null && clientPoList.size() > 0) {
-        return true;
-    } else {
-        return false;
-    }
+    ClientPo clientPo = clientDao.searchUnique(search);
+    ClientBo clientBo = modelMapper.map(clientPo, ClientBo.class);
+    return clientBo;
 }


Input:
void addConvertedValueOrValues() {
    boolean valueIsArray = valueToReturn.getClass().isArray();
    boolean valueIsIterable = valueToReturn instanceof Iterable<?>;
    InvocationResults results = expectation.getResults();
    if (valueIsArray || valueIsIterable || valueToReturn instanceof Iterator<?>) {
        if (returnType == void.class || hasReturnOfDifferentType()) {
            if (valueIsArray) {
                results.addReturnValues(valueToReturn);
            } else if (valueIsIterable) {
                results.addReturnValues((Iterable<?>) valueToReturn);
            } else {
                results.addDeferredReturnValues((Iterator<?>) valueToReturn);
            }
            return;
        }
    }
    expectation.substituteCascadedMockToBeReturnedIfNeeded(valueToReturn);
    results.addReturnValue(valueToReturn);
}

Output:
     }
-    expectation.substituteCascadedMockToBeReturnedIfNeeded(valueToReturn);
+    expectation.clearNextInstanceToMatchIfRecording();
     results.addReturnValue(valueToReturn);


Input:
public void handle(final DispatchTask task) throws ServerApiException {
    final Map<String, Object> lowercaseParams = new HashMap<String, Object>();
    final Map<String, String> params = task.getParams();
    for (final String key : params.keySet()) {
        final int arrayStartIndex = key.indexOf('[');
        final int arrayStartLastIndex = key.lastIndexOf('[');
        if (arrayStartIndex != arrayStartLastIndex) {
            throw new ServerApiException(ApiErrorCode.MALFORMED_PARAMETER_ERROR, "String_Node_Str" + key + "String_Node_Str");
        }
        if (arrayStartIndex > 0) {
            final int arrayEndIndex = key.indexOf(']');
            final int arrayEndLastIndex = key.lastIndexOf(']');
            if ((arrayEndIndex < arrayStartIndex) || (arrayEndIndex != arrayEndLastIndex)) {
                throw new ServerApiException(ApiErrorCode.MALFORMED_PARAMETER_ERROR, "String_Node_Str" + key + "String_Node_Str");
            }
            final int fieldIndex = key.indexOf('.');
            String fieldName = null;
            if (fieldIndex < arrayEndIndex) {
                throw new ServerApiException(ApiErrorCode.MALFORMED_PARAMETER_ERROR, "String_Node_Str" + key + "String_Node_Str");
            } else {
                fieldName = key.substring(fieldIndex + 1);
            }
            String paramName = key.substring(0, arrayStartIndex);
            paramName = paramName.toLowerCase();
            Map<Integer, Map> mapArray = null;
            Map<String, Object> mapValue = null;
            final String indexStr = key.substring(arrayStartIndex + 1, arrayEndIndex);
            int index = 0;
            boolean parsedIndex = false;
            try {
                if (indexStr != null) {
                    index = Integer.parseInt(indexStr);
                    parsedIndex = true;
                }
            } catch (final NumberFormatException nfe) {
                s_logger.warn("String_Node_Str" + key + "String_Node_Str");
            }
            if (!parsedIndex) {
                throw new ServerApiException(ApiErrorCode.MALFORMED_PARAMETER_ERROR, "String_Node_Str" + key + "String_Node_Str");
            }
            final Object value = lowercaseParams.get(paramName);
            if (value == null) {
                mapArray = new HashMap<Integer, Map>();
                mapValue = new HashMap<String, Object>();
                mapArray.put(Integer.valueOf(index), mapValue);
            } else if (value instanceof Map) {
                mapArray = (HashMap) value;
                mapValue = mapArray.get(Integer.valueOf(index));
                if (mapValue == null) {
                    mapValue = new HashMap<String, Object>();
                    mapArray.put(Integer.valueOf(index), mapValue);
                }
            }
            mapValue.put(fieldName, params.get(key));
            lowercaseParams.put(paramName, mapArray);
        } else {
            lowercaseParams.put(key.toLowerCase(), params.get(key));
        }
    }
    task.setParams(lowercaseParams);
}

Output:
     final Map<String, String> params = task.getParams();
-    for (final String key : params.keySet()) {
+    for (final Map.Entry<String, String> entry : params.entrySet()) {
+        final String key = entry.getKey();
         final int arrayStartIndex = key.indexOf('[');


Input:
public void computeAxis(float yMin, float yMax) {
    if (mViewPortHandler.contentHeight() > 10 && !mViewPortHandler.isFullyZoomedOutX()) {
        PointD p1 = mTrans.getValuesByTouchPoint(mViewPortHandler.contentLeft(), mViewPortHandler.contentTop());
        PointD p2 = mTrans.getValuesByTouchPoint(mViewPortHandler.contentRight(), mViewPortHandler.contentTop());
        if (!mYAxis.isInverted()) {
            yMin = (float) p1.x;
            yMax = (float) p2.x;
        } else {
            if (!mYAxis.isStartAtZeroEnabled())
                yMin = (float) Math.min(p1.x, p2.x);
            else
                yMin = 0;
            yMax = (float) Math.max(p1.x, p2.x);
        }
    }
    computeAxisValues(yMin, yMax);
}

Output:
         } else {
-            if (!mYAxis.isStartAtZeroEnabled())
-                yMin = (float) Math.min(p1.x, p2.x);
-            else
-                yMin = 0;
-            yMax = (float) Math.max(p1.x, p2.x);
+            yMin = (float) p2.x;
+            yMax = (float) p1.x;
         }


Input:
void updateRotation(int animFlags) {
    mPowerManager.setKeyboardVisibility(mLidOpen);
    int rotation = Surface.ROTATION_0;
    if (mLidOpen) {
        rotation = Surface.ROTATION_90;
    }
    try {
        mWindowManager.setRotation(rotation, true, animFlags);
    } catch (RemoteException e) {
    }
}

Output:
     try {
-        mWindowManager.setRotation(rotation, true, animFlags);
+        mWindowManager.setRotation(rotation, true, mFancyRotationAnimation | animFlags);
     } catch (RemoteException e) {


Input:
public void testGetTablesConnectionSchemaStringBoolean() {
    java.sql.Connection sqlConn = null;
    DatabaseMetaData metaData = null;
    String schemaName = "String_Node_Str";
    List<TdTable> tableList = new ArrayList<TdTable>();
    List<TdTable> retableList = new ArrayList<TdTable>();
    List<TdTable> resultList1 = null;
    List<TdTable> resultList2 = null;
    List<TdTable> resultList3 = null;
    String tablePattern = null;
    boolean loadFromDB = true;
    TdTable tableMock = Mockito.mock(TdTable.class);
    retableList.add(tableMock);
    ResultSet tables = Mockito.mock(ResultSet.class);
    try {
        Connection dataProvider = Mockito.mock(DatabaseConnection.class);
        Catalog catalog = Mockito.mock(Catalog.class);
        Schema schema = Mockito.mock(Schema.class);
        TypedReturnCode<java.sql.Connection> reConn = new TypedReturnCode<java.sql.Connection>();
        sqlConn = Mockito.mock(java.sql.Connection.class);
        reConn.setOk(true);
        reConn.setObject(sqlConn);
        ReturnCode rc = new ReturnCode(true);
        metaData = Mockito.mock(DatabaseMetaData.class);
        PowerMockito.mockStatic(MetadataConnectionUtils.class);
        Mockito.when(MetadataConnectionUtils.checkConnection((DatabaseConnection) dataProvider)).thenReturn(reConn);
        PowerMockito.mockStatic(ExtractMetaDataUtils.class);
        ExtractMetaDataUtils extract = Mockito.mock(ExtractMetaDataUtils.class);
        Mockito.when(ExtractMetaDataUtils.getInstance()).thenReturn(extract);
        Mockito.when(extract.getDatabaseMetaData(sqlConn, (DatabaseConnection) dataProvider, false)).thenReturn(metaData);
        PowerMockito.mockStatic(PackageHelper.class);
        Mockito.when(PackageHelper.getTables(schema)).thenReturn(tableList);
        MetadataFillFactory metadataMock = Mockito.mock(MetadataFillFactory.class);
        Mockito.when(metadataMock.fillTables((orgomg.cwm.objectmodel.core.Package) Mockito.eq(schema), Mockito.eq(metaData), Mockito.anyList(), Mockito.eq(tablePattern), (String[]) Mockito.any())).thenReturn(retableList).thenReturn(retableList);
        PowerMockito.mockStatic(MetadataFillFactory.class);
        Mockito.when(MetadataFillFactory.getDBInstance()).thenReturn(metadataMock);
        PowerMockito.mockStatic(ConnectionUtils.class);
        Mockito.when(ConnectionUtils.closeConnection(sqlConn)).thenReturn(rc);
        PowerMockito.mockStatic(SchemaHelper.class);
        Mockito.when(SchemaHelper.getTables(schema)).thenReturn(retableList);
        PowerMockito.mockStatic(CatalogHelper.class);
        Mockito.when(CatalogHelper.getParentCatalog(schema)).thenReturn(catalog);
        resultList1 = DqRepositoryViewService.getTables(dataProvider, schema, tablePattern, loadFromDB);
        tableList.add(tableMock);
        resultList2 = DqRepositoryViewService.getTables(dataProvider, schema, tablePattern, loadFromDB);
        loadFromDB = false;
        resultList3 = DqRepositoryViewService.getTables(dataProvider, schema, tablePattern, loadFromDB);
        Mockito.verify(metadataMock, Mockito.times(2)).fillTables((orgomg.cwm.objectmodel.core.Package) Mockito.eq(schema), Mockito.eq(metaData), Mockito.anyList(), Mockito.eq(tablePattern), (String[]) Mockito.any());
        Mockito.verify(metadataMock).setLinked(true);
        Mockito.verify(metadataMock).setLinked(false);
        Mockito.verifyZeroInteractions(tableMock, tables, dataProvider, schema, sqlConn, metaData, metadataMock, catalog);
        assertTrue(resultList1.size() == 1);
        assertTrue(resultList2.size() == 1);
        assertTrue(resultList3.size() == 1);
    } catch (Exception e) {
        e.printStackTrace();
        fail(e.getMessage());
    }
}

Output:
         PowerMockito.mockStatic(MetadataConnectionUtils.class);
-        Mockito.when(MetadataConnectionUtils.checkConnection((DatabaseConnection) dataProvider)).thenReturn(reConn);
+        Mockito.when(MetadataConnectionUtils.createConnection((DatabaseConnection) dataProvider)).thenReturn(reConn);
         PowerMockito.mockStatic(ExtractMetaDataUtils.class);


Input:
private UnresolvedRowHint convertRowToHint(RowArea row) {
    IRowContent rowContent = (IRowContent) row.getContent();
    ITableContent table = rowContent.getTable();
    InstanceID tableId = table.getInstanceID();
    InstanceID rowId = rowContent.getInstanceID();
    UnresolvedRowHint hint = new UnresolvedRowHint(tableId.toUniqueString(), rowId.toUniqueString());
    for (Iterator i = row.getChildren(); i.hasNext(); ) {
        AbstractArea area = (AbstractArea) i.next();
        String style = null;
        if (area instanceof CellArea) {
            CellArea cell = (CellArea) area;
            ICellContent cellContent = (ICellContent) cell.getContent();
            if (cellContent != null) {
                style = cellContent.getStyle().getCssText();
            }
            hint.addUnresolvedCell(style, cell.columnID, cell.colSpan, cell.rowSpan);
        }
    }
    return hint;
}

Output:
     UnresolvedRowHint hint = new UnresolvedRowHint(tableId.toUniqueString(), rowId.toUniqueString());
-    for (Iterator i = row.getChildren(); i.hasNext(); ) {
-        AbstractArea area = (AbstractArea) i.next();
-        String style = null;
-        if (area instanceof CellArea) {
-            CellArea cell = (CellArea) area;
-            ICellContent cellContent = (ICellContent) cell.getContent();
-            if (cellContent != null) {
-                style = cellContent.getStyle().getCssText();
+    if (row.cells != null) {
+        for (int i = 0; i < row.cells.length; i++) {
+            AbstractArea area = (AbstractArea) row.cells[i];
+            String style = null;
+            if (area instanceof DummyCell) {
+                CellArea cell = ((DummyCell) area).getCell();
+                ICellContent cellContent = (ICellContent) cell.getContent();
+                if (cellContent != null) {
+                    style = cellContent.getStyle().getCssText();
+                }
+                hint.addUnresolvedCell(style, cell.columnID, ((DummyCell) area).colSpan, ((DummyCell) area).rowSpan);
+            } else if (area instanceof CellArea) {
+                CellArea cell = (CellArea) area;
+                ICellContent cellContent = (ICellContent) cell.getContent();
+                if (cellContent != null) {
+                    style = cellContent.getStyle().getCssText();
+                }
+                hint.addUnresolvedCell(style, cell.columnID, cell.colSpan, cell.rowSpan);
             }


Input:
private Object buildObjectValuesFromDOMRecord(DOMRecord record, AbstractSession session, ObjectBuildingQuery query) {
    DirectMapContainerPolicy cp = (DirectMapContainerPolicy) getContainerPolicy();
    Object container = cp.containerInstance();
    org.w3c.dom.Element root = (Element) record.getDOM();
    NamedNodeMap attributes = root.getAttributes();
    Attr next;
    String localName;
    for (int i = 0; i < attributes.getLength(); i++) {
        next = (Attr) attributes.item(i);
        localName = next.getLocalName();
        if (null == localName) {
            localName = next.getName();
        }
        QName key = new QName(next.getNamespaceURI(), localName);
        String value = next.getValue();
        cp.addInto(key, value, container, session);
    }
    return container;
}

Output:
     String localName;
-    for (int i = 0; i < attributes.getLength(); i++) {
+    int numberOfAtts = attributes.getLength();
+    for (int i = 0; i < numberOfAtts; i++) {
         next = (Attr) attributes.item(i);


Input:
boolean unifyWithSubtype(NominalType other, List<String> typeParameters, Multimap<String, JSType> typeMultimap) {
    if (this.rawType != other.rawType) {
        return false;
    }
    if (this.rawType.typeParameters.isEmpty()) {
        return true;
    }
    Preconditions.checkState(!typeMap.isEmpty());
    if (other.typeMap.isEmpty()) {
        return true;
    }
    boolean hasUnified = true;
    for (String typeParam : rawType.typeParameters) {
        hasUnified = hasUnified && typeMap.get(typeParam).unifyWithSubtype(other.typeMap.get(typeParam), typeParameters, typeMultimap);
    }
    return hasUnified;
}

Output:
     }
-    if (this.rawType.typeParameters.isEmpty()) {
+    if (!isGeneric()) {
         return true;


Input:
private static String getFilename(String title, String filename) {
    filename = getFilename(title, filename);
    if (filename != null)
        filename = Utils.replaceExtension(filename, "String_Node_Str");
    return filename;
}

Output:
 private static String getFilename(String title, String filename) {
-    filename = getFilename(title, filename);
+    filename = Utils.getFilename(title, filename);
     if (filename != null)


Input:
static boolean identMatch(final ParameterDescriptorGroup parameters, final String regex, final String identifier) {
    if (identifier != null) {
        for (final Identifier id : parameters.getIdentifiers()) {
            if (Constants.EPSG.equals(id.getCodeSpace())) {
                return identifier.equals(id.getCode());
            }
        }
    }
    return parameters.getName().getCode().matches(regex);
}

Output:
     }
-    return parameters.getName().getCode().matches(regex);
+    return parameters.getName().getCode().replace('_', ' ').matches(regex);
 }


Input:
public Map<String, String> getOptions(String world) {
    String optionNode = (world == null) ? "String_Node_Str" : "String_Node_Str" + world + "String_Node_Str";
    ConfigurationSection optionsSection = this.node.getConfigurationSection(optionNode);
    if (optionsSection != null) {
        return this.collectOptions(optionsSection);
    }
    return new HashMap<String, String>(0);
}

Output:
 public Map<String, String> getOptions(String world) {
-    String optionNode = (world == null) ? "String_Node_Str" : "String_Node_Str" + world + "String_Node_Str";
-    ConfigurationSection optionsSection = this.node.getConfigurationSection(optionNode);
+    ConfigurationSection optionsSection = this.node.getConfigurationSection(formatPath(world, "String_Node_Str"));
     if (optionsSection != null) {