Input:
public static AVM2Code parse(InputStream is, ConstantPool constants, Trait trait, MissingSymbolHandler missingHandler, MethodBody body, MethodInfo info) throws IOException, ParseException {
    AVM2Code code = new AVM2Code();
    List<OffsetItem> offsetItems = new ArrayList<>();
    List<LabelItem> labelItems = new ArrayList<>();
    List<ABCException> exceptions = new ArrayList<>();
    List<Integer> exceptionIndices = new ArrayList<>();
    int offset = 0;
    Flasm3Lexer lexer = new Flasm3Lexer(new InputStreamReader(is, "String_Node_Str"));
    ParsedSymbol symb;
    AVM2Instruction lastIns = null;
    List<String> exceptionsFrom = new ArrayList<>();
    List<String> exceptionsTo = new ArrayList<>();
    List<String> exceptionsTargets = new ArrayList<>();
    info.flags = 0;
    info.name_index = 0;
    List<Integer> paramTypes = new ArrayList<>();
    List<Integer> paramNames = new ArrayList<>();
    List<ValueKind> optional = new ArrayList<>();
    do {
        symb = lexer.lex();
        if (Arrays.asList(ParsedSymbol.TYPE_KEYWORD_BODY, ParsedSymbol.TYPE_KEYWORD_CODE, ParsedSymbol.TYPE_KEYWORD_METHOD).contains(symb.type)) {
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_TRAIT) {
            if (trait == null) {
                throw new ParseException("String_Node_Str", lexer.yyline());
            }
            symb = lexer.lex();
            switch(symb.type) {
                case ParsedSymbol.TYPE_KEYWORD_METHOD:
                case ParsedSymbol.TYPE_KEYWORD_GETTER:
                case ParsedSymbol.TYPE_KEYWORD_SETTER:
                    if (!(trait instanceof TraitMethodGetterSetter)) {
                        throw new ParseException("String_Node_Str", lexer.yyline());
                    }
                    TraitMethodGetterSetter tm = (TraitMethodGetterSetter) trait;
                    switch(symb.type) {
                        case ParsedSymbol.TYPE_KEYWORD_METHOD:
                            tm.kindType = Trait.TRAIT_METHOD;
                            break;
                        case ParsedSymbol.TYPE_KEYWORD_GETTER:
                            tm.kindType = Trait.TRAIT_GETTER;
                            break;
                        case ParsedSymbol.TYPE_KEYWORD_SETTER:
                            tm.kindType = Trait.TRAIT_SETTER;
                            break;
                    }
                    tm.name_index = parseMultiName(constants, lexer);
                    expected(ParsedSymbol.TYPE_KEYWORD_DISPID, "String_Node_Str", lexer);
                    symb = lexer.lex();
                    expected(symb, ParsedSymbol.TYPE_INTEGER, "String_Node_Str");
                    tm.disp_id = (int) (long) (Long) symb.value;
                    break;
                case ParsedSymbol.TYPE_KEYWORD_FUNCTION:
                    if (!(trait instanceof TraitFunction)) {
                        throw new ParseException("String_Node_Str", lexer.yyline());
                    }
                    break;
            }
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_NAME) {
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_STRING, "String_Node_Str");
            info.name_index = constants.getStringId((String) symb.value, true);
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_PARAM) {
            paramTypes.add(parseMultiName(constants, lexer));
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_PARAMNAME) {
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_STRING, "String_Node_Str");
            paramNames.add(constants.getStringId((String) symb.value, true));
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_OPTIONAL) {
            optional.add(parseValue(constants, lexer));
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_MAXSTACK) {
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_INTEGER, "String_Node_Str");
            body.max_stack = (int) (long) (Long) symb.value;
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_LOCALCOUNT) {
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_INTEGER, "String_Node_Str");
            body.max_regs = (int) (long) (Long) symb.value;
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_INITSCOPEDEPTH) {
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_INTEGER, "String_Node_Str");
            body.init_scope_depth = (int) (long) (Long) symb.value;
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_MAXSCOPEDEPTH) {
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_INTEGER, "String_Node_Str");
            body.max_scope_depth = (int) (long) (Long) symb.value;
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_RETURNS) {
            info.ret_type = parseMultiName(constants, lexer);
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_FLAG) {
            symb = lexer.lex();
            switch(symb.type) {
                case ParsedSymbol.TYPE_KEYWORD_EXPLICIT:
                    info.setFlagExplicit();
                    break;
                case ParsedSymbol.TYPE_KEYWORD_HAS_OPTIONAL:
                    info.setFlagHas_optional();
                    break;
                case ParsedSymbol.TYPE_KEYWORD_HAS_PARAM_NAMES:
                    info.setFlagHas_paramnames();
                    break;
                case ParsedSymbol.TYPE_KEYWORD_IGNORE_REST:
                    info.setFlagIgnore_Rest();
                    break;
                case ParsedSymbol.TYPE_KEYWORD_NEED_ACTIVATION:
                    info.setFlagNeed_activation();
                    break;
                case ParsedSymbol.TYPE_KEYWORD_NEED_ARGUMENTS:
                    info.setFlagNeed_Arguments();
                    break;
                case ParsedSymbol.TYPE_KEYWORD_NEED_REST:
                    info.setFlagNeed_rest();
                    break;
                case ParsedSymbol.TYPE_KEYWORD_SET_DXNS:
                    info.setFlagSetsdxns();
                    break;
            }
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_KEYWORD_TRY) {
            expected(ParsedSymbol.TYPE_KEYWORD_FROM, "String_Node_Str", lexer);
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_IDENTIFIER, "String_Node_Str");
            exceptionsFrom.add((String) symb.value);
            expected(ParsedSymbol.TYPE_KEYWORD_TO, "String_Node_Str", lexer);
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_IDENTIFIER, "String_Node_Str");
            exceptionsTo.add((String) symb.value);
            expected(ParsedSymbol.TYPE_KEYWORD_TARGET, "String_Node_Str", lexer);
            symb = lexer.lex();
            expected(symb, ParsedSymbol.TYPE_IDENTIFIER, "String_Node_Str");
            exceptionsTargets.add((String) symb.value);
            expected(ParsedSymbol.TYPE_KEYWORD_TYPE, "String_Node_Str", lexer);
            ABCException ex = new ABCException();
            ex.type_index = parseMultiName(constants, lexer);
            expected(ParsedSymbol.TYPE_KEYWORD_NAME, "String_Node_Str", lexer);
            ex.name_index = parseMultiName(constants, lexer);
            exceptions.add(ex);
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_EXCEPTION_START) {
            int exIndex = (Integer) symb.value;
            int listIndex = exceptionIndices.indexOf(exIndex);
            if (listIndex == -1) {
                throw new ParseException("String_Node_Str", lexer.yyline());
            }
            exceptions.get(listIndex).start = offset;
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_EXCEPTION_END) {
            int exIndex = (Integer) symb.value;
            int listIndex = exceptionIndices.indexOf(exIndex);
            if (listIndex == -1) {
                throw new ParseException("String_Node_Str", lexer.yyline());
            }
            exceptions.get(listIndex).end = offset;
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_EXCEPTION_TARGET) {
            int exIndex = (Integer) symb.value;
            int listIndex = exceptionIndices.indexOf(exIndex);
            if (listIndex == -1) {
                throw new ParseException("String_Node_Str", lexer.yyline());
            }
            exceptions.get(listIndex).target = offset;
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_EOF) {
            break;
        }
        if (symb.type == ParsedSymbol.TYPE_COMMENT) {
            if (lastIns != null) {
                lastIns.comment = (String) symb.value;
            }
            continue;
        }
        if (symb.type == ParsedSymbol.TYPE_INSTRUCTION_NAME) {
            if (((String) symb.value).toLowerCase(Locale.ENGLISH).equals("String_Node_Str")) {
                ParsedSymbol exIndex = lexer.lex();
                if (exIndex.type != ParsedSymbol.TYPE_INTEGER) {
                    throw new ParseException("String_Node_Str", lexer.yyline());
                }
                ParsedSymbol exName = lexer.lex();
                if (exName.type != ParsedSymbol.TYPE_MULTINAME) {
                    throw new ParseException("String_Node_Str", lexer.yyline());
                }
                ParsedSymbol exType = lexer.lex();
                if (exType.type != ParsedSymbol.TYPE_MULTINAME) {
                    throw new ParseException("String_Node_Str", lexer.yyline());
                }
                ABCException ex = new ABCException();
                ex.name_index = checkMultinameIndex(constants, (int) (long) (Long) exName.value, lexer.yyline());
                ex.type_index = checkMultinameIndex(constants, (int) (long) (Long) exType.value, lexer.yyline());
                exceptions.add(ex);
                exceptionIndices.add((int) (long) (Long) exIndex.value);
                continue;
            }
            boolean insFound = false;
            for (InstructionDefinition def : AVM2Code.instructionSet) {
                if (def.instructionName.equals((String) symb.value)) {
                    insFound = true;
                    List<Integer> operandsList = new ArrayList<>();
                    for (int i = 0; i < def.operands.length; i++) {
                        ParsedSymbol parsedOperand = lexer.lex();
                        switch(def.operands[i]) {
                            case AVM2Code.DAT_MULTINAME_INDEX:
                                lexer.pushback(parsedOperand);
                                operandsList.add(parseMultiName(constants, lexer));
                                break;
                            case AVM2Code.DAT_STRING_INDEX:
                                if (parsedOperand.type == ParsedSymbol.TYPE_STRING) {
                                    int sid = constants.getStringId((String) parsedOperand.value);
                                    if (sid == 0) {
                                        if ((missingHandler != null) && (missingHandler.missingString((String) parsedOperand.value))) {
                                            sid = constants.addString((String) parsedOperand.value);
                                        } else {
                                            throw new ParseException("String_Node_Str", lexer.yyline());
                                        }
                                    }
                                    operandsList.add(sid);
                                } else {
                                    throw new ParseException("String_Node_Str", lexer.yyline());
                                }
                                break;
                            case AVM2Code.DAT_INT_INDEX:
                                if (parsedOperand.type == ParsedSymbol.TYPE_INTEGER) {
                                    long intVal = (Long) parsedOperand.value;
                                    int iid = constants.getIntId(intVal);
                                    if (iid == 0) {
                                        if ((missingHandler != null) && (missingHandler.missingInt(intVal))) {
                                            iid = constants.addInt(intVal);
                                        } else {
                                            throw new ParseException("String_Node_Str", lexer.yyline());
                                        }
                                    }
                                    operandsList.add(iid);
                                } else {
                                    throw new ParseException("String_Node_Str", lexer.yyline());
                                }
                                break;
                            case AVM2Code.DAT_UINT_INDEX:
                                if (parsedOperand.type == ParsedSymbol.TYPE_INTEGER) {
                                    long intVal = (Long) parsedOperand.value;
                                    int iid = constants.getUIntId(intVal);
                                    if (iid == 0) {
                                        if ((missingHandler != null) && (missingHandler.missingUInt(intVal))) {
                                            iid = constants.addUInt(intVal);
                                        } else {
                                            throw new ParseException("String_Node_Str", lexer.yyline());
                                        }
                                    }
                                    operandsList.add(iid);
                                } else {
                                    throw new ParseException("String_Node_Str", lexer.yyline());
                                }
                                break;
                            case AVM2Code.DAT_DOUBLE_INDEX:
                                if ((parsedOperand.type == ParsedSymbol.TYPE_INTEGER) || (parsedOperand.type == ParsedSymbol.TYPE_FLOAT)) {
                                    double doubleVal = 0;
                                    if (parsedOperand.type == ParsedSymbol.TYPE_INTEGER) {
                                        doubleVal = (Long) parsedOperand.value;
                                    }
                                    if (parsedOperand.type == ParsedSymbol.TYPE_FLOAT) {
                                        doubleVal = (Double) parsedOperand.value;
                                    }
                                    int did = constants.getDoubleId(doubleVal);
                                    if (did == 0) {
                                        if ((missingHandler != null) && (missingHandler.missingDouble(doubleVal))) {
                                            did = constants.addDouble(doubleVal);
                                        } else {
                                            throw new ParseException("String_Node_Str", lexer.yyline());
                                        }
                                    }
                                    operandsList.add(did);
                                } else {
                                    throw new ParseException("String_Node_Str", lexer.yyline());
                                }
                                break;
                            case AVM2Code.DAT_OFFSET:
                                if (parsedOperand.type == ParsedSymbol.TYPE_IDENTIFIER) {
                                    offsetItems.add(new OffsetItem((String) parsedOperand.value, code.code.size(), i));
                                    operandsList.add(0);
                                } else {
                                    throw new ParseException("String_Node_Str", lexer.yyline());
                                }
                                break;
                            case AVM2Code.DAT_CASE_BASEOFFSET:
                                if (parsedOperand.type == ParsedSymbol.TYPE_IDENTIFIER) {
                                    offsetItems.add(new CaseOffsetItem((String) parsedOperand.value, code.code.size(), i));
                                    operandsList.add(0);
                                } else {
                                    throw new ParseException("String_Node_Str", lexer.yyline());
                                }
                                break;
                            case AVM2Code.OPT_CASE_OFFSETS:
                                if (parsedOperand.type == ParsedSymbol.TYPE_INTEGER) {
                                    int patCount = (int) (long) (Long) parsedOperand.value;
                                    operandsList.add(patCount);
                                    for (int c = 0; c <= patCount; c++) {
                                        parsedOperand = lexer.lex();
                                        if (parsedOperand.type == ParsedSymbol.TYPE_IDENTIFIER) {
                                            offsetItems.add(new CaseOffsetItem((String) parsedOperand.value, code.code.size(), i + (c + 1)));
                                            operandsList.add(0);
                                        } else {
                                            throw new ParseException("String_Node_Str", lexer.yyline());
                                        }
                                    }
                                } else {
                                    throw new ParseException("String_Node_Str", lexer.yyline());
                                }
                                break;
                            default:
                                if (parsedOperand.type == ParsedSymbol.TYPE_INTEGER) {
                                    operandsList.add((int) (long) (Long) parsedOperand.value);
                                } else {
                                    throw new ParseException("String_Node_Str", lexer.yyline());
                                }
                        }
                    }
                    int[] operands = new int[operandsList.size()];
                    for (int i = 0; i < operandsList.size(); i++) {
                        operands[i] = operandsList.get(i);
                    }
                    lastIns = new AVM2Instruction(offset, def, operands, new byte[0]);
                    code.code.add(lastIns);
                    offset += lastIns.getBytes().length;
                    break;
                }
            }
            if (symb.value.toString().toLowerCase().equals("String_Node_Str")) {
                lastIns = new AVM2Instruction(offset, new DeobfuscatePopIns(), new int[0], new byte[0]);
                code.code.add(lastIns);
                offset += lastIns.getBytes().length;
                insFound = true;
            }
            if (!insFound) {
                throw new ParseException("String_Node_Str" + (String) symb.value, lexer.yyline());
            }
        } else if (symb.type == ParsedSymbol.TYPE_LABEL) {
            labelItems.add(new LabelItem((String) symb.value, offset));
        } else {
            throw new ParseException("String_Node_Str", lexer.yyline());
        }
    } while (symb.type != ParsedSymbol.TYPE_EOF);
    code.compact();
    for (LabelItem li : labelItems) {
        int ind;
        ind = exceptionsFrom.indexOf(li.label);
        if (ind > -1) {
            exceptions.get(ind).start = li.offset;
        }
        ind = exceptionsTo.indexOf(li.label);
        if (ind > -1) {
            exceptions.get(ind).end = li.offset;
        }
        ind = exceptionsTargets.indexOf(li.label);
        if (ind > -1) {
            exceptions.get(ind).target = li.offset;
        }
    }
    for (OffsetItem oi : offsetItems) {
        for (LabelItem li : labelItems) {
            if (oi.label.equals(li.label)) {
                AVM2Instruction ins = code.code.get((int) oi.insPosition);
                int relOffset;
                if (oi instanceof CaseOffsetItem) {
                    relOffset = li.offset - (int) ins.offset;
                } else {
                    relOffset = li.offset - ((int) ins.offset + ins.getBytes().length);
                }
                ins.operands[oi.insOperandIndex] = relOffset;
            }
        }
    }
    body.exceptions = new ABCException[exceptions.size()];
    for (int e = 0; e < exceptions.size(); e++) {
        body.exceptions[e] = exceptions.get(e);
    }
    info.param_types = new int[paramTypes.size()];
    for (int i = 0; i < paramTypes.size(); i++) {
        info.param_types[i] = paramTypes.get(i);
    }
    if (info.flagHas_paramnames()) {
        info.paramNames = new int[paramNames.size()];
        for (int i = 0; i < paramNames.size(); i++) {
            info.paramNames[i] = paramNames.get(i);
        }
    }
    if (info.flagHas_optional()) {
        info.optional = new ValueKind[optional.size()];
        for (int i = 0; i < optional.size(); i++) {
            info.optional[i] = optional.get(i);
        }
    }
    return code;
}

Output:
             symb = lexer.lex();
-            expected(symb, ParsedSymbol.TYPE_STRING, "String_Node_Str");
-            info.name_index = constants.getStringId((String) symb.value, true);
+            if (symb.type == ParsedSymbol.TYPE_KEYWORD_NULL) {
+                info.name_index = 0;
+            } else {
+                expected(symb, ParsedSymbol.TYPE_STRING, "String_Node_Str");
+                info.name_index = constants.getStringId((String) symb.value, true);
+            }
             continue;


Input:
public static long highestOneBit(long i) {
    int high = (int) (i >> 32);
    if (high != 0) {
        return ((long) Integer.highestOneBit(high)) << 32;
    } else {
        return Integer.highestOneBit((int) i);
    }
}

Output:
     } else {
-        return Integer.highestOneBit((int) i);
+        return Integer.highestOneBit((int) i) & 0xFFFFFFFFL;
     }


Input:
public void setFileInformation(SrvSession sess, final TreeConnection tree, final String name, final FileInfo info) throws IOException {
    final ContentContext ctx = (ContentContext) tree.getContext();
    if (logger.isDebugEnabled()) {
        logger.debug("String_Node_Str" + name + "String_Node_Str" + info);
    }
    NetworkFile networkFile = info.getNetworkFile();
    try {
        if (sess.isPseudoFilesEnabled() && ctx.isPseudoFilesEnabled()) {
            String[] paths = FileName.splitPath(name);
            NodeRef dirNodeRef = getNodeForPath(tree, paths[0]);
            if (ctx.getPseudoFileOverlay().isPseudoFile(dirNodeRef, paths[1])) {
                if (logger.isDebugEnabled()) {
                    logger.debug("String_Node_Str");
                }
                return;
            }
        }
        NodeRef nodeRef = getNodeForPath(tree, name);
        if (permissionService.hasPermission(nodeRef, PermissionService.WRITE) == AccessStatus.DENIED) {
            if (logger.isDebugEnabled()) {
                logger.debug("String_Node_Str" + name);
            }
            throw new AccessDeniedException("String_Node_Str" + name);
        }
        getPolicyFilter().disableBehaviour(ContentModel.ASPECT_VERSIONABLE);
        if (info.hasSetFlag(FileInfo.SetDeleteOnClose) && info.hasDeleteOnClose()) {
            if (logger.isDebugEnabled()) {
                logger.debug("String_Node_Str" + name);
            }
            if (permissionService.hasPermission(nodeRef, PermissionService.DELETE) == AccessStatus.DENIED) {
                throw new AccessDeniedException("String_Node_Str" + name);
            }
            lockService.checkForLock(nodeRef);
            if (fileFolderService.exists(nodeRef)) {
                boolean isFolder = true;
                ContentFileInfo cInfo = getCifsHelper().getFileInformation(nodeRef, false, isLockedFilesAsOffline);
                if (cInfo != null && cInfo.isDirectory() == false) {
                    isFolder = false;
                }
                if (isFolder == true && getCifsHelper().isFolderEmpty(nodeRef) == false) {
                    throw new DirectoryNotEmptyException(name);
                }
            }
        }
        if (info.isHidden() && !nodeService.hasAspect(nodeRef, ContentModel.ASPECT_HIDDEN)) {
            if (logger.isDebugEnabled()) {
                logger.debug("String_Node_Str" + name);
            }
        }
        if (info.hasSetFlag(FileInfo.SetAllocationSize)) {
            if (logger.isDebugEnabled()) {
                logger.debug("String_Node_Str" + name + info.getAllocationSize());
            }
        }
        Map<QName, Serializable> auditableProps = new HashMap<QName, Serializable>(5);
        if (info.hasSetFlag(FileInfo.SetCreationDate) && info.hasCreationDateTime()) {
            Date createDate = new Date(info.getCreationDateTime());
            auditableProps.put(ContentModel.PROP_CREATED, createDate);
            if (logger.isDebugEnabled()) {
                logger.debug("String_Node_Str" + name + "String_Node_Str" + createDate);
            }
        }
        if (info.hasSetFlag(FileInfo.SetModifyDate) && info.hasModifyDateTime()) {
            Date modifyDate = new Date(info.getModifyDateTime());
            auditableProps.put(ContentModel.PROP_MODIFIED, modifyDate);
            if (networkFile != null && !networkFile.isReadOnly()) {
                networkFile.setModifyDate(info.getModifyDateTime());
            }
            if (logger.isDebugEnabled()) {
                logger.debug("String_Node_Str" + name + "String_Node_Str" + modifyDate);
            }
        }
        if (auditableProps.size() > 0) {
            getPolicyFilter().disableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
            nodeService.addProperties(nodeRef, auditableProps);
            if (logger.isDebugEnabled()) {
                logger.debug("String_Node_Str" + auditableProps + "String_Node_Str" + name);
            }
        }
        return;
    } catch (org.alfresco.repo.security.permissions.AccessDeniedException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("String_Node_Str" + name);
        }
        throw new AccessDeniedException("String_Node_Str" + name);
    } catch (AlfrescoRuntimeException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("String_Node_Str", ex);
        }
        throw new IOException("String_Node_Str" + name, ex);
    }
}

Output:
         }
-        if (info.isHidden() && !nodeService.hasAspect(nodeRef, ContentModel.ASPECT_HIDDEN)) {
+        if (info.hasSetFlag(FileInfo.SetAttributes)) {
             if (logger.isDebugEnabled()) {


Input:
private GraphTargetItem command(TypeItem thisType, String pkg, Reference<Boolean> needsActivation, List<String> importedClasses, List<Integer> openedNamespaces, Stack<Loop> loops, Map<Loop, String> loopLabels, HashMap<String, Integer> registerVars, boolean inFunction, boolean inMethod, int forinlevel, boolean mustBeCommand, List<AssignableAVM2Item> variables) throws IOException, AVM2ParseException {
    LexBufferer buf = new LexBufferer();
    lexer.addListener(buf);
    GraphTargetItem ret = null;
    if (debugMode) {
        System.out.println("String_Node_Str");
    }
    ParsedSymbol s = lex();
    if (s.type == SymbolType.EOF) {
        return null;
    }
    String loopLabel = null;
    if (s.group == SymbolGroup.IDENTIFIER) {
        ParsedSymbol sc = lex();
        if (sc.type == SymbolType.COLON) {
            loopLabel = s.value.toString();
            s = lex();
        } else {
            lexer.pushback(sc);
        }
    }
    if (s.type == SymbolType.DEFAULT) {
        ParsedSymbol sx = lex();
        if (sx.group != SymbolGroup.IDENTIFIER) {
            lexer.pushback(sx);
        } else {
            if (!sx.value.equals("String_Node_Str")) {
                lexer.pushback(sx);
            } else {
                expectedType(SymbolType.NAMESPACE);
                expectedType(SymbolType.ASSIGN);
                GraphTargetItem ns = expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables);
                ret = new DefaultXMLNamespace(null, ns);
            }
        }
    }
    if (ret == null) {
        switch(s.type) {
            case USE:
                expectedType(SymbolType.NAMESPACE);
                GraphTargetItem ns = type(thisType, pkg, needsActivation, importedClasses, openedNamespaces, variables);
                openedNamespaces.add(abc.constants.getNamespaceId(new Namespace(Namespace.KIND_PACKAGE, abc.constants.getStringId(ns.toString(), true)), 0, true));
                break;
            case WITH:
                needsActivation.setVal(true);
                expectedType(SymbolType.PARENT_OPEN);
                GraphTargetItem wvar = expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables);
                if (!isNameOrProp(wvar)) {
                    throw new AVM2ParseException("String_Node_Str", lexer.yyline());
                }
                expectedType(SymbolType.PARENT_CLOSE);
                expectedType(SymbolType.CURLY_OPEN);
                List<AssignableAVM2Item> withVars = new ArrayList<>();
                List<GraphTargetItem> wcmd = commands(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, withVars);
                variables.addAll(withVars);
                for (AssignableAVM2Item a : withVars) {
                    if (a instanceof UnresolvedAVM2Item) {
                        UnresolvedAVM2Item ua = (UnresolvedAVM2Item) a;
                        ua.scopeStack.add(0, wvar);
                    }
                }
                expectedType(SymbolType.CURLY_CLOSE);
                ret = new WithAVM2Item(null, wvar, wcmd);
                ((WithAVM2Item) ret).subvariables = withVars;
                break;
            case FUNCTION:
                s = lexer.lex();
                expected(s, lexer.yyline(), SymbolGroup.IDENTIFIER);
                needsActivation.setVal(true);
                ret = (function(pkg, false, needsActivation, importedClasses, 0, thisType, openedNamespaces, s.value.toString(), false, variables));
                break;
            case VAR:
                s = lex();
                expected(s, lexer.yyline(), SymbolGroup.IDENTIFIER);
                String varIdentifier = s.value.toString();
                s = lex();
                GraphTargetItem type;
                if (s.type == SymbolType.COLON) {
                    type = type(thisType, pkg, needsActivation, importedClasses, openedNamespaces, variables);
                    s = lex();
                } else {
                    type = new UnboundedTypeItem();
                }
                if (s.type == SymbolType.ASSIGN) {
                    GraphTargetItem varval = (expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables));
                    ret = new NameAVM2Item(type, lexer.yyline(), varIdentifier, varval, true, openedNamespaces);
                    variables.add((NameAVM2Item) ret);
                } else {
                    ret = new NameAVM2Item(type, lexer.yyline(), varIdentifier, null, true, openedNamespaces);
                    variables.add((NameAVM2Item) ret);
                    lexer.pushback(s);
                }
                break;
            case CURLY_OPEN:
                ret = new BlockItem(null, commands(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, variables));
                expectedType(SymbolType.CURLY_CLOSE);
                break;
            case SUPER:
                ParsedSymbol ss2 = lex();
                if (ss2.type == SymbolType.PARENT_OPEN) {
                    List<GraphTargetItem> args = call(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, variables);
                    ret = new ConstructSuperAVM2Item(null, new LocalRegAVM2Item(null, 0, null), args);
                } else {
                    lexer.pushback(ss2);
                    lexer.pushback(s);
                }
                break;
            case IF:
                expectedType(SymbolType.PARENT_OPEN);
                GraphTargetItem ifExpr = (expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables));
                expectedType(SymbolType.PARENT_CLOSE);
                GraphTargetItem onTrue = command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, true, variables);
                List<GraphTargetItem> onTrueList = new ArrayList<>();
                onTrueList.add(onTrue);
                s = lex();
                List<GraphTargetItem> onFalseList = null;
                if (s.type == SymbolType.ELSE) {
                    onFalseList = new ArrayList<>();
                    onFalseList.add(command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, true, variables));
                } else {
                    lexer.pushback(s);
                }
                ret = new IfItem(null, ifExpr, onTrueList, onFalseList);
                break;
            case WHILE:
                expectedType(SymbolType.PARENT_OPEN);
                List<GraphTargetItem> whileExpr = new ArrayList<>();
                whileExpr.add(commaExpression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, variables));
                expectedType(SymbolType.PARENT_CLOSE);
                List<GraphTargetItem> whileBody = new ArrayList<>();
                Loop wloop = new Loop(uniqId(), null, null);
                if (loopLabel != null) {
                    loopLabels.put(wloop, loopLabel);
                }
                loops.push(wloop);
                whileBody.add(command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, true, variables));
                ret = new WhileItem(null, wloop, whileExpr, whileBody);
                break;
            case DO:
                List<GraphTargetItem> doBody = new ArrayList<>();
                Loop dloop = new Loop(uniqId(), null, null);
                loops.push(dloop);
                if (loopLabel != null) {
                    loopLabels.put(dloop, loopLabel);
                }
                doBody.add(command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, true, variables));
                expectedType(SymbolType.WHILE);
                expectedType(SymbolType.PARENT_OPEN);
                List<GraphTargetItem> doExpr = new ArrayList<>();
                doExpr.add(commaExpression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, variables));
                expectedType(SymbolType.PARENT_CLOSE);
                ret = new DoWhileItem(null, dloop, doBody, doExpr);
                break;
            case FOR:
                s = lex();
                boolean forin = false;
                boolean each = false;
                GraphTargetItem collection = null;
                if (s.type == SymbolType.EACH) {
                    each = true;
                    forin = true;
                    s = lex();
                }
                expected(s, lexer.yyline(), SymbolType.PARENT_OPEN);
                GraphTargetItem firstCommand = command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, false, variables);
                if (firstCommand instanceof NameAVM2Item) {
                    NameAVM2Item nai = (NameAVM2Item) firstCommand;
                    if (nai.isDefinition() && nai.getAssignedValue() == null) {
                        firstCommand = expression1(firstCommand, firstCommand.getPrecedence(), thisType, pkg, needsActivation, importedClasses, openedNamespaces, true, registerVars, inFunction, inMethod, true, variables);
                    }
                }
                InAVM2Item inexpr = null;
                if (firstCommand instanceof InAVM2Item) {
                    forin = true;
                    inexpr = (InAVM2Item) firstCommand;
                } else {
                    if (forin) {
                        throw new AVM2ParseException("String_Node_Str", lexer.yyline());
                    }
                }
                Loop floop = new Loop(uniqId(), null, null);
                loops.push(floop);
                if (loopLabel != null) {
                    loopLabels.put(floop, loopLabel);
                }
                List<GraphTargetItem> forFinalCommands = new ArrayList<>();
                GraphTargetItem forExpr = null;
                List<GraphTargetItem> forFirstCommands = new ArrayList<>();
                if (!forin) {
                    if (firstCommand != null) {
                        forFirstCommands.add(firstCommand);
                    }
                    forExpr = (expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables));
                    expectedType(SymbolType.SEMICOLON);
                    forFinalCommands.add(command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, true, variables));
                }
                expectedType(SymbolType.PARENT_CLOSE);
                List<GraphTargetItem> forBody = new ArrayList<>();
                forBody.add(command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forin ? forinlevel + 1 : forinlevel, true, variables));
                if (forin) {
                    if (each) {
                        ret = new ForEachInAVM2Item(null, floop, inexpr, forBody);
                    } else {
                        ret = new ForInAVM2Item(null, floop, inexpr, forBody);
                    }
                } else {
                    ret = new ForItem(null, floop, forFirstCommands, forExpr, forFinalCommands, forBody);
                }
                break;
            case SWITCH:
                Loop sloop = new Loop(-uniqId(), null, null);
                loops.push(sloop);
                if (loopLabel != null) {
                    loopLabels.put(sloop, loopLabel);
                }
                expectedType(SymbolType.PARENT_OPEN);
                GraphTargetItem switchExpr = expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables);
                expectedType(SymbolType.PARENT_CLOSE);
                expectedType(SymbolType.CURLY_OPEN);
                s = lex();
                int exprReg = 0;
                for (int i = 0; i < 256; i++) {
                    if (!registerVars.containsValue(i)) {
                        registerVars.put("String_Node_Str" + uniqId(), i);
                        exprReg = i;
                        break;
                    }
                }
                List<List<ActionIf>> caseIfs = new ArrayList<>();
                List<List<GraphTargetItem>> caseCmds = new ArrayList<>();
                List<GraphTargetItem> caseExprsAll = new ArrayList<>();
                List<Integer> valueMapping = new ArrayList<>();
                int pos = 0;
                while (s.type == SymbolType.CASE) {
                    List<GraphTargetItem> caseExprs = new ArrayList<>();
                    while (s.type == SymbolType.CASE) {
                        GraphTargetItem curCaseExpr = expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables);
                        caseExprs.add(curCaseExpr);
                        expectedType(SymbolType.COLON);
                        s = lex();
                        caseExprsAll.add(curCaseExpr);
                        valueMapping.add(pos);
                    }
                    pos++;
                    lexer.pushback(s);
                    List<GraphTargetItem> caseCmd = commands(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, variables);
                    caseCmds.add(caseCmd);
                    s = lex();
                }
                List<GraphTargetItem> defCmd = new ArrayList<>();
                if (s.type == SymbolType.DEFAULT) {
                    expectedType(SymbolType.COLON);
                    defCmd = commands(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, variables);
                    s = lexer.lex();
                }
                expected(s, lexer.yyline(), SymbolType.CURLY_CLOSE);
                ret = new SwitchItem(null, sloop, switchExpr, caseExprsAll, caseCmds, defCmd, valueMapping);
                break;
            case BREAK:
                s = lex();
                long bloopId = 0;
                if (loops.isEmpty()) {
                    throw new AVM2ParseException("String_Node_Str", lexer.yyline());
                }
                if (s.group == SymbolGroup.IDENTIFIER) {
                    String breakLabel = s.value.toString();
                    for (Loop l : loops) {
                        if (breakLabel.equals(loopLabels.get(l))) {
                            bloopId = l.id;
                            break;
                        }
                    }
                    if (bloopId == 0) {
                        throw new AVM2ParseException("String_Node_Str", lexer.yyline());
                    }
                } else {
                    lexer.pushback(s);
                    bloopId = loops.peek().id;
                }
                ret = new BreakItem(null, bloopId);
                break;
            case CONTINUE:
                s = lex();
                long cloopId = 0;
                if (loops.isEmpty()) {
                    throw new AVM2ParseException("String_Node_Str", lexer.yyline());
                }
                if (s.group == SymbolGroup.IDENTIFIER) {
                    String continueLabel = s.value.toString();
                    for (Loop l : loops) {
                        if (l.id < 0) {
                            continue;
                        }
                        if (continueLabel.equals(loopLabels.get(l))) {
                            cloopId = l.id;
                            break;
                        }
                    }
                    if (cloopId == -1) {
                        throw new AVM2ParseException("String_Node_Str", lexer.yyline());
                    }
                } else {
                    lexer.pushback(s);
                    for (int i = loops.size() - 1; i >= 0; i--) {
                        if (loops.get(i).id >= 0) {
                            cloopId = loops.get(i).id;
                            break;
                        }
                    }
                    if (cloopId <= 0) {
                        throw new AVM2ParseException("String_Node_Str", lexer.yyline());
                    }
                }
                ret = new ContinueItem(null, cloopId);
                break;
            case RETURN:
                GraphTargetItem retexpr = expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, true, registerVars, inFunction, inMethod, true, variables);
                if (retexpr == null) {
                    ret = new ReturnVoidAVM2Item(null);
                } else {
                    ret = new ReturnValueAVM2Item(null, retexpr);
                }
                break;
            case TRY:
                needsActivation.setVal(true);
                List<GraphTargetItem> tryCommands = new ArrayList<>();
                tryCommands.add(command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, true, variables));
                s = lex();
                boolean found = false;
                List<List<GraphTargetItem>> catchCommands = new ArrayList<>();
                List<NameAVM2Item> catchExceptions = new ArrayList<>();
                int varCnt = variables.size();
                List<List<AssignableAVM2Item>> catchesVars = new ArrayList<>();
                while (s.type == SymbolType.CATCH) {
                    expectedType(SymbolType.PARENT_OPEN);
                    s = lex();
                    expected(s, lexer.yyline(), SymbolGroup.IDENTIFIER, SymbolType.THIS, SymbolType.SUPER, SymbolType.STRING_OP);
                    String enamestr = s.value.toString();
                    expectedType(SymbolType.COLON);
                    GraphTargetItem etype = type(thisType, pkg, needsActivation, importedClasses, openedNamespaces, variables);
                    NameAVM2Item e = new NameAVM2Item(etype, lexer.yyline(), enamestr, new ExceptionAVM2Item(null), true, openedNamespaces);
                    variables.add(e);
                    catchExceptions.add(e);
                    e.setSlotNumber(1);
                    e.setSlotScope(Integer.MAX_VALUE);
                    expectedType(SymbolType.PARENT_CLOSE);
                    List<GraphTargetItem> cc = new ArrayList<>();
                    List<AssignableAVM2Item> catchVars = new ArrayList<>();
                    cc.add(command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, true, catchVars));
                    catchesVars.add(catchVars);
                    variables.addAll(catchVars);
                    for (AssignableAVM2Item a : catchVars) {
                        if (a instanceof UnresolvedAVM2Item) {
                            UnresolvedAVM2Item ui = (UnresolvedAVM2Item) a;
                            if (ui.getVariableName().equals(e.getVariableName())) {
                                try {
                                    ui.resolve(null, new ArrayList<GraphTargetItem>(), new ArrayList<String>(), abc, otherABCs, new ArrayList<MethodBody>(), variables);
                                } catch (CompilationException ex) {
                                }
                                ui.setSlotNumber(e.getSlotNumber());
                                ui.setSlotScope(e.getSlotScope());
                            }
                        }
                    }
                    catchCommands.add(cc);
                    s = lex();
                    found = true;
                }
                for (int i = varCnt; i < variables.size(); i++) {
                    AssignableAVM2Item av = variables.get(i);
                    if (av instanceof UnresolvedAVM2Item) {
                        UnresolvedAVM2Item ui = (UnresolvedAVM2Item) av;
                        for (NameAVM2Item e : catchExceptions) {
                            if (ui.getVariableName().equals(e.getVariableName())) {
                                try {
                                    ui.resolve(null, new ArrayList<GraphTargetItem>(), new ArrayList<String>(), abc, otherABCs, new ArrayList<MethodBody>(), variables);
                                } catch (CompilationException ex) {
                                }
                                ui.setSlotNumber(e.getSlotNumber());
                                ui.setSlotScope(e.getSlotScope());
                            }
                        }
                    }
                }
                List<GraphTargetItem> finallyCommands = null;
                if (s.type == SymbolType.FINALLY) {
                    finallyCommands = new ArrayList<>();
                    finallyCommands.add(command(thisType, pkg, needsActivation, importedClasses, openedNamespaces, loops, loopLabels, registerVars, inFunction, inMethod, forinlevel, true, variables));
                    found = true;
                    s = lex();
                }
                if (!found) {
                    expected(s, lexer.yyline(), SymbolType.CATCH, SymbolType.FINALLY);
                }
                lexer.pushback(s);
                TryAVM2Item tai = new TryAVM2Item(tryCommands, null, catchCommands, finallyCommands);
                tai.catchVariables = catchesVars;
                tai.catchExceptions2 = catchExceptions;
                ret = tai;
                break;
            case THROW:
                ret = new ThrowAVM2Item(null, expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables));
                break;
            default:
                GraphTargetItem valcmd = expressionCommands(s, registerVars, inFunction, inMethod, forinlevel, variables);
                if (valcmd != null) {
                    ret = valcmd;
                    break;
                }
                if (s.type == SymbolType.SEMICOLON) {
                    return null;
                }
                lexer.pushback(s);
                ret = expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables);
                if (debugMode) {
                    System.out.println("String_Node_Str");
                }
        }
    }
    if (debugMode) {
        System.out.println("String_Node_Str");
    }
    lexer.removeListener(buf);
    if (ret == null) {
        buf.pushAllBack(lexer);
        ret = expression(thisType, pkg, needsActivation, importedClasses, openedNamespaces, registerVars, inFunction, inMethod, true, variables);
    }
    s = lex();
    if ((s != null) && (s.type != SymbolType.SEMICOLON)) {
        lexer.pushback(s);
    }
    return ret;
}

Output:
                     if (nai.isDefinition() && nai.getAssignedValue() == null) {
-                        firstCommand = expression1(firstCommand, firstCommand.getPrecedence(), thisType, pkg, needsActivation, importedClasses, openedNamespaces, true, registerVars, inFunction, inMethod, true, variables);
+                        firstCommand = expression1(firstCommand, GraphTargetItem.NOPRECEDENCE, thisType, pkg, needsActivation, importedClasses, openedNamespaces, true, registerVars, inFunction, inMethod, true, variables);
                     }


Input:
private List<StateParam> genPrestateStates(AvaticaStatement statement) {
    List<StateParam> params = new ArrayList<StateParam>();
    List<Object> values = ((KylinJdbc41PreparedStatement) statement).getParameterValues();
    for (int i = 0; i < values.size(); i++) {
        Object value = values.get(i);
        params.add(new StateParam(value.getClass().getCanonicalName(), (null == value) ? null : String.valueOf(value)));
    }
    return params;
}

Output:
         Object value = values.get(i);
-        params.add(new StateParam(value.getClass().getCanonicalName(), (null == value) ? null : String.valueOf(value)));
+        params.add(new StateParam(value.getClass().getCanonicalName(), String.valueOf(value)));
     }


Input:
public Collection<? extends IPersistentObject> getToRefresh() {
    return toLock;
}

Output:
 public Collection<? extends IPersistentObject> getToRefresh() {
-    return toLock;
+    List<IPersistentObject> toRefr = new ArrayList<>(toLock);
+    toRefr.addAll(lol[0].getSpecTestCase().getUnmodifiableNodeList());
+    return toRefr;
 }


Input:
protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    mc.getTextureManager().bindTexture(BOILER_TEXTURES);
    int k = (width - xSize) / 2;
    int l = (height - ySize) / 2;
    GL11.glEnable(3042);
    drawTexturedModalRect(k, l, 0, 0, xSize, ySize);
    int i1;
    i1 = tileEntity.getBurnTimeRemainingScaled(14);
    drawTexturedModalRect(k + 58, l + 15 + 14 - i1, 176, 14 - i1, 14, i1);
    GL11.glDisable(3042);
    FluidTank tank = tileEntity.getTank();
    if (tank == null) {
        return;
    }
    FluidStack fluidStack = tank.getFluid();
    if (fluidStack == null) {
        return;
    }
    float fill = fluidStack.amount / (float) tank.getCapacity();
    drawFluid(new FluidStack(FluidHelper.getWaterFluid(), 1), (int) (fill * 58.0F), k + 81, l + 14, 16, 58, false);
    mc.getTextureManager().bindTexture(BOILER_TEXTURES);
    drawTexturedModalRect(k + 80, l + 13, 190, 0, 18, 60);
    fill = tileEntity.getPressure();
    fill = Math.min(fill, 1.0F);
    FluidStack stack = new FluidStack(FluidHelper.getWaterFluid(), 1);
    if (FluidRegistry.isFluidRegistered("String_Node_Str")) {
        stack = new FluidStack(FluidRegistry.getFluid("String_Node_Str"), 1);
    }
    drawFluid(stack, (int) (fill * 58.0F), k + 104, l + 14, 16, 58, true);
    mc.getTextureManager().bindTexture(BOILER_TEXTURES);
    drawTexturedModalRect(k + 103, l + 13, 190, 0, 18, 60);
    GL11.glDisable(3042);
}

Output:
     drawTexturedModalRect(k + 80, l + 13, 190, 0, 18, 60);
-    fill = tileEntity.getPressure();
-    fill = Math.min(fill, 1.0F);
+    fill = Math.min(tileEntity.getPressure(), 1F);
     FluidStack stack = new FluidStack(FluidHelper.getWaterFluid(), 1);


Input:
public void hideNew(Integer itemDataId, List<PropertyBean> properties, UserAccountBean ub, RuleSetBean ruleSet) {
    ItemDataBean itemDataBeanA = (ItemDataBean) getItemDataDAO().findByPK(itemDataId);
    EventCRFBean eventCrfBeanA = (EventCRFBean) getEventCRFDAO().findByPK(itemDataBeanA.getEventCRFId());
    ItemGroupMetadataBean itemGroupMetadataBeanA = (ItemGroupMetadataBean) getItemGroupMetadataDAO().findByItemAndCrfVersion(itemDataBeanA.getItemId(), eventCrfBeanA.getCRFVersionId());
    Boolean isGroupARepeating = isGroupRepeating(itemGroupMetadataBeanA);
    String itemGroupAOrdinal = getExpressionService().getGroupOrdninalCurated(ruleSet.getTarget().getValue());
    for (PropertyBean propertyBean : properties) {
        String oid = propertyBean.getOid();
        ItemOrItemGroupHolder itemOrItemGroup = getItemOrItemGroup(oid);
        if (itemOrItemGroup.getItemBean() != null) {
            String expression = getExpressionService().constructFullExpressionIfPartialProvided(propertyBean.getOid(), ruleSet.getTarget().getValue());
            ItemBean itemBeanB = getExpressionService().getItemBeanFromExpression(expression);
            ItemGroupBean itemGroupBeanB = getExpressionService().getItemGroupExpression(expression);
            EventCRFBean eventCrfBeanB = eventCrfBeanA;
            ItemGroupMetadataBean itemGroupMetadataBeanB = (ItemGroupMetadataBean) getItemGroupMetadataDAO().findByItemAndCrfVersion(itemBeanB.getId(), eventCrfBeanB.getCRFVersionId());
            Boolean isGroupBRepeating = isGroupRepeating(itemGroupMetadataBeanB);
            String itemGroupBOrdinal = getExpressionService().getGroupOrdninalCurated(expression);
            List<ItemDataBean> itemDataBeans = new ArrayList<ItemDataBean>();
            if (!isGroupARepeating && !isGroupBRepeating) {
                ItemDataBean oidBasedItemData = oneToOne(itemDataBeanA, eventCrfBeanA, itemGroupMetadataBeanA, itemBeanB, itemGroupMetadataBeanB, eventCrfBeanB, ub, 1);
                itemDataBeans.add(oidBasedItemData);
            }
            if (!isGroupARepeating && isGroupBRepeating && itemGroupBOrdinal.equals("String_Node_Str")) {
                List<ItemDataBean> oidBasedItemDatas = oneToMany(itemDataBeanA, eventCrfBeanA, itemGroupMetadataBeanA, itemBeanB, itemGroupBeanB, itemGroupMetadataBeanB, eventCrfBeanB, ub);
                itemDataBeans.addAll(oidBasedItemDatas);
            }
            if (!isGroupARepeating && isGroupBRepeating && !itemGroupBOrdinal.equals("String_Node_Str")) {
                ItemDataBean oidBasedItemData = oneToIndexedMany(itemDataBeanA, eventCrfBeanA, itemGroupMetadataBeanA, itemBeanB, itemGroupBeanB, itemGroupMetadataBeanB, eventCrfBeanB, ub, Integer.valueOf(itemGroupBOrdinal));
                itemDataBeans.add(oidBasedItemData);
            }
            if (isGroupARepeating && isGroupBRepeating && !itemGroupBOrdinal.equals("String_Node_Str")) {
                ItemDataBean oidBasedItemData = oneToIndexedMany(itemDataBeanA, eventCrfBeanA, itemGroupMetadataBeanA, itemBeanB, itemGroupBeanB, itemGroupMetadataBeanB, eventCrfBeanB, ub, Integer.valueOf(itemGroupBOrdinal));
                itemDataBeans.add(oidBasedItemData);
            }
            if (isGroupARepeating && isGroupBRepeating && itemGroupBOrdinal.equals("String_Node_Str")) {
                ItemDataBean oidBasedItemData = oneToIndexedMany(itemDataBeanA, eventCrfBeanA, itemGroupMetadataBeanA, itemBeanB, itemGroupBeanB, itemGroupMetadataBeanB, eventCrfBeanB, ub, Integer.valueOf(itemGroupAOrdinal));
                itemDataBeans.add(oidBasedItemData);
            }
            for (ItemDataBean oidBasedItemData : itemDataBeans) {
                ItemFormMetadataBean itemFormMetadataBean = getItemFormMetadataDAO().findByItemIdAndCRFVersionId(itemOrItemGroup.getItemBean().getId(), eventCrfBeanA.getCRFVersionId());
                DynamicsItemFormMetadataBean dynamicsMetadataBean = getDynamicsItemFormMetadataBean(itemFormMetadataBean, eventCrfBeanA, oidBasedItemData);
                if (dynamicsMetadataBean == null && oidBasedItemData.getValue().equals("String_Node_Str")) {
                    hideItem(itemFormMetadataBean, eventCrfBeanA, oidBasedItemData);
                } else if (dynamicsMetadataBean != null && dynamicsMetadataBean.isShowItem() && oidBasedItemData.getValue().equals("String_Node_Str") && !itemsAlreadyShown.contains(new Integer(oidBasedItemData.getItemId()))) {
                    dynamicsMetadataBean.setShowItem(false);
                    getDynamicsItemFormMetadataDao().saveOrUpdate(dynamicsMetadataBean);
                }
            }
        } else {
            logger.debug("String_Node_Str" + oid);
            ItemGroupBean itemGroupBean = itemOrItemGroup.getItemGroupBean();
            ArrayList sectionBeans = getSectionDAO().findAllByCRFVersionId(eventCrfBeanA.getCRFVersionId());
            for (int i = 0; i < sectionBeans.size(); i++) {
                SectionBean sectionBean = (SectionBean) sectionBeans.get(i);
                List<ItemGroupMetadataBean> itemGroupMetadataBeans = getItemGroupMetadataDAO().findMetaByGroupAndSection(itemGroupBean.getId(), eventCrfBeanA.getCRFVersionId(), sectionBean.getId());
                for (ItemGroupMetadataBean itemGroupMetadataBean : itemGroupMetadataBeans) {
                    if (itemGroupMetadataBean.getItemGroupId() == itemGroupBean.getId()) {
                        DynamicsItemGroupMetadataBean dynamicsGroupBean = getDynamicsItemGroupMetadataBean(itemGroupMetadataBean, eventCrfBeanA);
                        if (dynamicsGroupBean == null) {
                            hideGroup(itemGroupMetadataBean, eventCrfBeanA);
                        } else if (dynamicsGroupBean != null && !dynamicsGroupBean.isShowGroup()) {
                            dynamicsGroupBean.setShowGroup(false);
                            getDynamicsItemGroupMetadataDao().saveOrUpdate(dynamicsGroupBean);
                        } else if (eventCrfBeanA.getStage().equals(DataEntryStage.DOUBLE_DATA_ENTRY)) {
                            dynamicsGroupBean.setPassedDde(1);
                            getDynamicsItemGroupMetadataDao().saveOrUpdate(dynamicsGroupBean);
                        }
                    }
                }
            }
        }
    }
    resetItemCounter();
}

Output:
                     hideItem(itemFormMetadataBean, eventCrfBeanA, oidBasedItemData);
-                } else if (dynamicsMetadataBean != null && dynamicsMetadataBean.isShowItem() && oidBasedItemData.getValue().equals("String_Node_Str") && !itemsAlreadyShown.contains(new Integer(oidBasedItemData.getItemId()))) {
+                } else if (dynamicsMetadataBean != null && dynamicsMetadataBean.isShowItem() && oidBasedItemData.getValue().equals("String_Node_Str")) {
                     dynamicsMetadataBean.setShowItem(false);


Input:
public void addTestStep(NodeDTO testStep) {
    if (!(testStep instanceof RefTestCaseDTO || testStep instanceof CapDTO)) {
        throw new IllegalArgumentException();
    }
    this.m_testSteps.add(testStep);
}

Output:
 public void addTestStep(NodeDTO testStep) {
-    if (!(testStep instanceof RefTestCaseDTO || testStep instanceof CapDTO)) {
+    if (!(testStep instanceof RefTestCaseDTO || testStep instanceof CapDTO || testStep instanceof CommentDTO)) {
         throw new IllegalArgumentException();


Input:
private void onSendingClusterPdu() {
    while (true) {
        try {
            ClusterServicePdu pdu = _clusterPduOutgoingQueue.take();
            ClusterService peerService = null;
            for (int i = 0; i < 2; i++) {
                try {
                    peerService = getPeerService(pdu.getDestPeer());
                } catch (RemoteException e) {
                    s_logger.error("String_Node_Str" + pdu.getDestPeer());
                }
                if (peerService != null) {
                    try {
                        if (s_logger.isDebugEnabled()) {
                            s_logger.debug("String_Node_Str" + getSelfPeerName() + "String_Node_Str" + pdu.getDestPeer() + "String_Node_Str" + pdu.getAgentId() + "String_Node_Str" + pdu.getSequenceId() + "String_Node_Str" + pdu.getAckSequenceId() + "String_Node_Str" + pdu.getJsonPackage());
                        }
                        long startTick = System.currentTimeMillis();
                        String strResult = peerService.execute(pdu);
                        if (s_logger.isDebugEnabled()) {
                            s_logger.debug("String_Node_Str" + getSelfPeerName() + "String_Node_Str" + pdu.getDestPeer() + "String_Node_Str" + (System.currentTimeMillis() - startTick) + "String_Node_Str" + pdu.getAgentId() + "String_Node_Str" + pdu.getSequenceId() + "String_Node_Str" + pdu.getAckSequenceId() + "String_Node_Str" + pdu.getJsonPackage());
                        }
                        if ("String_Node_Str".equals(strResult))
                            break;
                    } catch (RemoteException e) {
                        invalidatePeerService(pdu.getDestPeer());
                        if (s_logger.isInfoEnabled()) {
                            s_logger.info("String_Node_Str" + pdu.getDestPeer() + "String_Node_Str" + i + "String_Node_Str" + e.getMessage());
                        }
                    }
                }
            }
        } catch (InterruptedException e) {
        } catch (Throwable e) {
            s_logger.error("String_Node_Str", e);
        }
    }
}

Output:
         try {
-            ClusterServicePdu pdu = _clusterPduOutgoingQueue.take();
+            ClusterServicePdu pdu = popOutgoingClusterPdu(1000);
+            if (pdu == null)
+                continue;
             ClusterService peerService = null;


Input:
protected Response find(String persistenceUnit, String type, String key, HttpHeaders hh, UriInfo ui, URI baseURI) {
    PersistenceContext app = getPersistenceFactory().get(persistenceUnit, baseURI, null);
    if (app == null || app.getClass(type) == null) {
        if (app == null) {
            JPARSLogger.fine("String_Node_Str", new Object[] { persistenceUnit });
        } else {
            JPARSLogger.fine("String_Node_Str", new Object[] { type, persistenceUnit });
        }
        return Response.status(Status.NOT_FOUND).build();
    }
    Map<String, String> discriminators = getParameterMap(ui, persistenceUnit);
    Object id = IdHelper.buildId(app, type, key, discriminators);
    Object entity = app.find(discriminators, type, id, getHintMap(ui));
    if (entity == null) {
        JPARSLogger.fine("String_Node_Str", new Object[] { type, key, persistenceUnit });
        return Response.status(Status.NOT_FOUND).build();
    } else {
        return Response.ok(new StreamingOutputMarshaller(app, entity, hh.getAcceptableMediaTypes())).build();
    }
}

Output:
     Map<String, String> discriminators = getParameterMap(ui, persistenceUnit);
-    Object id = IdHelper.buildId(app, type, key, discriminators);
+    Object id = IdHelper.buildId(app, type, key);
     Object entity = app.find(discriminators, type, id, getHintMap(ui));


Input:
protected void getIp(NicProfile nic, DataCenter dc, VirtualMachineProfile<? extends VirtualMachine> vm, Network network) throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException {
    if (nic.getIp4Address() == null) {
        PublicIp ip = _networkMgr.assignPublicIpAddress(dc.getId(), vm.getOwner(), VlanType.VirtualNetwork, null);
        nic.setIp4Address(ip.getAddress());
        nic.setGateway(ip.getGateway());
        nic.setNetmask(ip.getNetmask());
        nic.setIsolationUri(IsolationType.Vlan.toUri(ip.getVlanTag()));
        nic.setBroadcastType(BroadcastDomainType.Vlan);
        nic.setBroadcastUri(BroadcastDomainType.Vlan.toUri(ip.getVlanTag()));
        nic.setFormat(AddressFormat.Ip4);
        nic.setReservationId(String.valueOf(ip.getVlanTag()));
        nic.setMacAddress(ip.getMacAddress());
    }
    nic.setDns1(dc.getDns1());
    nic.setDns2(dc.getDns2());
}

Output:
     if (nic.getIp4Address() == null) {
-        PublicIp ip = _networkMgr.assignPublicIpAddress(dc.getId(), vm.getOwner(), VlanType.VirtualNetwork, null);
+        PublicIp ip = _networkMgr.assignPublicIpAddress(dc.getId(), vm.getOwner(), dc.getNetworkType().equals(NetworkType.Basic) ? VlanType.DirectAttached : VlanType.VirtualNetwork, null);
         nic.setIp4Address(ip.getAddress());


Input:
public boolean canUproot(World world, int x, int y, int z) {
    if (!world.isRemote) {
        TileEntity te = world.getTileEntity(x, y, z);
        if (te != null && te instanceof TileEntityCrop) {
            TileEntityCrop crop = (TileEntityCrop) te;
            if (crop.hasPlant()) {
                ArrayList<ItemStack> drops = new ArrayList<ItemStack>();
                if (crop.isMature()) {
                    drops.addAll(SeedHelper.getPlantFruits((ItemSeeds) crop.seed, world, x, y, z, crop.gain, crop.seedMeta));
                }
                drops.add(crop.getSeedStack());
                for (ItemStack drop : drops) {
                    this.dropBlockAsItem(world, x, y, z, drop);
                }
            }
            crop.clearPlant();
        }
    }
    return false;
}

Output:
                 if (crop.isMature()) {
-                    drops.addAll(SeedHelper.getPlantFruits((ItemSeeds) crop.seed, world, x, y, z, crop.gain, crop.seedMeta));
+                    drops.addAll(SeedHelper.getPlantFruits(crop.seed, world, x, y, z, crop.gain, crop.seedMeta));
                 }


Input:
public ArrayList<String> columnNames() {
    if (columnNames != null)
        return columnNames;
    LinkedHashSet<String> result = new LinkedHashSet<>();
    if (!(Marshallable.class.isAssignableFrom(keyType())))
        result.add("String_Node_Str");
    if (!(Marshallable.class.isAssignableFrom(valueType())))
        result.add("String_Node_Str");
    else {
        for (final Field declaredFields : valueType().getDeclaredFields()) {
            result.add(declaredFields.getName());
        }
    }
    columnNames = new ArrayList<>(result);
    return columnNames;
}

Output:
     LinkedHashSet<String> result = new LinkedHashSet<>();
-    if (!(Marshallable.class.isAssignableFrom(keyType())))
+    if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))
         result.add("String_Node_Str");


Input:
private void migrateIndexers(OldConfig oldConfig, BaseConfig newConfig) {
    List<IndexerConfig> indexerConfigs = new ArrayList<>();
    for (Indexer oldIndexer : oldConfig.getIndexers()) {
        IndexerConfig newIndexer = new IndexerConfig();
        newIndexer.setEnabled(oldIndexer.isEnabled());
        newIndexer.setHost(oldIndexer.getHost());
        newIndexer.setTimeout(oldIndexer.getTimeout());
        newIndexer.setDownloadLimit(oldIndexer.getDownloadLimit());
        newIndexer.setHitLimit(oldIndexer.getHitLimit());
        newIndexer.setHitLimitResetTime(oldIndexer.getHitLimitResetTime());
        newIndexer.setName(oldIndexer.getName());
        newIndexer.setApiKey(oldIndexer.getApikey());
        newIndexer.setLoadLimitOnRandom(oldIndexer.getLoadLimitOnRandom());
        newIndexer.setPassword(oldIndexer.getPassword());
        newIndexer.setUsername(oldIndexer.getUsername());
        newIndexer.setUserAgent(oldIndexer.getUserAgent());
        newIndexer.setPreselect(oldIndexer.isPreselect());
        newIndexer.setScore(oldIndexer.getScore());
        if (!Strings.isNullOrEmpty(oldIndexer.getType())) {
            try {
                newIndexer.setSearchModuleType(SearchModuleType.valueOf(oldIndexer.getAccessType().toUpperCase()));
            } catch (IllegalArgumentException e) {
                continue;
            }
        } else {
            continue;
        }
        if (newIndexer.getSearchModuleType() == SearchModuleType.NEWZNAB) {
            if (!Strings.isNullOrEmpty(oldIndexer.getBackend())) {
                try {
                    newIndexer.setBackend(BackendType.valueOf(oldIndexer.getAccessType().toUpperCase()));
                } catch (IllegalArgumentException e) {
                    continue;
                }
            }
        }
        newIndexer.setShowOnSearch(oldIndexer.isPreselect());
        newIndexer.setEnabledCategories(oldIndexer.getCategories());
        newIndexer.setSupportedSearchIds(null);
        if (oldIndexer.getSearchTypes() != null && oldIndexer.getSearchTypes().isEmpty()) {
            newIndexer.setSupportedSearchTypes(new ArrayList<>());
            for (String s : oldIndexer.getSearchTypes()) {
                try {
                    newIndexer.getSupportedSearchTypes().add(ActionAttribute.valueOf(s));
                } catch (IllegalArgumentException e) {
                }
            }
        }
        newIndexer.setCategoryMapping(new IndexerCategoryConfig());
        newIndexer.setGeneralMinSize(oldIndexer.getGeneralMinSize());
        if (!Strings.isNullOrEmpty(oldIndexer.getAccessType())) {
            try {
                newIndexer.setEnabledForSearchSource(SearchSourceRestriction.valueOf(oldIndexer.getAccessType().toUpperCase()));
            } catch (IllegalArgumentException e) {
                newIndexer.setEnabledForSearchSource(SearchSourceRestriction.BOTH);
            }
        }
        indexerConfigs.add(newIndexer);
    }
    newConfig.setIndexers(indexerConfigs);
}

Output:
     for (Indexer oldIndexer : oldConfig.getIndexers()) {
-        IndexerConfig newIndexer = new IndexerConfig();
-        newIndexer.setEnabled(oldIndexer.isEnabled());
-        newIndexer.setHost(oldIndexer.getHost());
-        newIndexer.setTimeout(oldIndexer.getTimeout());
-        newIndexer.setDownloadLimit(oldIndexer.getDownloadLimit());
-        newIndexer.setHitLimit(oldIndexer.getHitLimit());
-        newIndexer.setHitLimitResetTime(oldIndexer.getHitLimitResetTime());
-        newIndexer.setName(oldIndexer.getName());
-        newIndexer.setApiKey(oldIndexer.getApikey());
-        newIndexer.setLoadLimitOnRandom(oldIndexer.getLoadLimitOnRandom());
-        newIndexer.setPassword(oldIndexer.getPassword());
-        newIndexer.setUsername(oldIndexer.getUsername());
-        newIndexer.setUserAgent(oldIndexer.getUserAgent());
-        newIndexer.setPreselect(oldIndexer.isPreselect());
-        newIndexer.setScore(oldIndexer.getScore());
-        if (!Strings.isNullOrEmpty(oldIndexer.getType())) {
-            try {
-                newIndexer.setSearchModuleType(SearchModuleType.valueOf(oldIndexer.getAccessType().toUpperCase()));
-            } catch (IllegalArgumentException e) {
+        logger.info("String_Node_Str", oldIndexer.getName());
+        try {
+            if (oldIndexer.getType().toUpperCase().equals("String_Node_Str")) {
+                logAsWarningAndAdd(messages, "String_Node_Str");
                 continue;


Input:
protected void saveChange(File file, boolean added) {
    if (isSmartlySharedType(file)) {
        if (!added) {
            stopSmartSharingType(file);
        }
    } else {
        data.setSharedWithFriend(file, id, added);
    }
}

Output:
 protected void saveChange(File file, boolean added) {
-    if (isSmartlySharedType(file)) {
-        if (!added) {
-            stopSmartSharingType(file);
-        }
-    } else {
-        data.setSharedWithFriend(file, id, added);
-    }
+    data.setSharedWithFriend(file, id, added);
 }


Input:
public void mapFromArquillianDescriptorAndSystemPropertiesTest() {
    ArquillianDescriptor descriptor = Descriptors.create(ArquillianDescriptor.class).extension("String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str");
    System.clearProperty("String_Node_Str");
    System.clearProperty("String_Node_Str");
    System.clearProperty("String_Node_Str");
    System.setProperty("String_Node_Str", "String_Node_Str");
    MockDroneConfiguration configuration = ConfigurationMapper.fromArquillianDescriptor(descriptor, new MockDroneConfiguration(), Default.class);
    ConfigurationMapper.fromSystemConfiguration(configuration, Default.class);
    Assert.assertNotNull("String_Node_Str", configuration.getMapMap());
    Assert.assertEquals("String_Node_Str", 3, configuration.getMapMap().size());
    Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
    Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
    Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
}

Output:
 public void mapFromArquillianDescriptorAndSystemPropertiesTest() {
-    ArquillianDescriptor descriptor = Descriptors.create(ArquillianDescriptor.class).extension("String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str");
-    System.clearProperty("String_Node_Str");
-    System.clearProperty("String_Node_Str");
-    System.clearProperty("String_Node_Str");
-    System.setProperty("String_Node_Str", "String_Node_Str");
-    MockDroneConfiguration configuration = ConfigurationMapper.fromArquillianDescriptor(descriptor, new MockDroneConfiguration(), Default.class);
-    ConfigurationMapper.fromSystemConfiguration(configuration, Default.class);
-    Assert.assertNotNull("String_Node_Str", configuration.getMapMap());
-    Assert.assertEquals("String_Node_Str", 3, configuration.getMapMap().size());
-    Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
-    Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
-    Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
+    try {
+        ArquillianDescriptor descriptor = Descriptors.create(ArquillianDescriptor.class).extension("String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str").property("String_Node_Str", "String_Node_Str");
+        System.setProperty("String_Node_Str", "String_Node_Str");
+        MockDroneConfiguration configuration = ConfigurationMapper.fromArquillianDescriptor(descriptor, new MockDroneConfiguration(), Default.class);
+        ConfigurationMapper.fromSystemConfiguration(configuration, Default.class);
+        Assert.assertNotNull("String_Node_Str", configuration.getMapMap());
+        Assert.assertEquals("String_Node_Str", 3, configuration.getMapMap().size());
+        Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
+        Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
+        Assert.assertEquals("String_Node_Str", "String_Node_Str", configuration.getMapMap().get("String_Node_Str"));
+    } finally {
+        System.clearProperty("String_Node_Str");
+    }
 }


Input:
public void setFields() {
    switch(type) {
        case TextFile:
            this.list.setSelectedIndex(0);
            break;
        case MachineLearningMethod:
            this.list.setSelectedIndex(1);
            break;
        case CSVFile:
            this.list.setSelectedIndex(2);
            break;
        case TrainingFile:
            this.list.setSelectedIndex(3);
            break;
        case NEAT:
            this.list.setSelectedIndex(4);
            break;
    }
}

Output:
 public void setFields() {
-    switch(type) {
+    switch(theType) {
         case TextFile:


Input:
private void processFiles(File[] files, File outputFile, List<String> additionalArgs) {
    if (files.length == 0) {
        return;
    }
    Process p = null;
    try {
        List<String> inputFileList = new LinkedList<String>();
        for (int i = 0; i < files.length; i++) {
            if (files[i].exists() && files[i].isFile()) {
                inputFileList.add(files[i].getCanonicalPath());
            } else {
                log.warn("String_Node_Str" + files[i] + "String_Node_Str" + "String_Node_Str");
            }
        }
        List<String> cmd = new LinkedList<String>();
        cmd.add("String_Node_Str");
        cmd.addAll(inputFileList);
        cmd.add("String_Node_Str");
        cmd.add(outputFile.getCanonicalPath());
        cmd.add("String_Node_Str");
        cmd.add(Settings.get(WaybackSettings.WAYBACK_AGGREGATOR_TEMP_DIR));
        if (additionalArgs != null || additionalArgs.isEmpty()) {
            for (String argument : additionalArgs) {
                ArgumentNotValid.checkTrue(argument.indexOf(' ') == -1, "String_Node_Str" + argument + "String_Node_Str");
            }
            cmd.addAll(additionalArgs);
        }
        ProcessBuilder pb = new ProcessBuilder(cmd);
        pb.environment().put("String_Node_Str", "String_Node_Str");
        pb.directory(new File(System.getProperty("String_Node_Str")));
        p = pb.start();
        p.waitFor();
        if (p.exitValue() != 0) {
            log.error("String_Node_Str" + p.exitValue());
        }
    } catch (Exception e) {
        log.error("String_Node_Str", e);
    }
}

Output:
         cmd.add(Settings.get(WaybackSettings.WAYBACK_AGGREGATOR_TEMP_DIR));
-        if (additionalArgs != null || additionalArgs.isEmpty()) {
+        if (additionalArgs != null && !additionalArgs.isEmpty()) {
             for (String argument : additionalArgs) {


Input:
protected static String name(String value) {
    final char[] ca = value.toCharArray();
    for (int i = 0; i < ca.length; i++) {
        final char c = ca[i];
        ca[i] = (c >= '0') ? Character.toUpperCase(c) : '_';
    }
    return String.valueOf(ca);
}

Output:
     }
-    return String.valueOf(ca);
+    return buffer.toString();
 }


Input:
private static void buildLists() {
    underlyingSetCodesPerFormat.put(STANDARD, new ArrayList<>());
    underlyingSetCodesPerFormat.put(EXTENDED, new ArrayList<>());
    underlyingSetCodesPerFormat.put(FRONTIER, new ArrayList<>());
    underlyingSetCodesPerFormat.put(MODERN, new ArrayList<>());
    underlyingSetCodesPerFormat.put(VINTAGE_LEGACY, new ArrayList<>());
    underlyingSetCodesPerFormat.put(CUSTOM, new ArrayList<>());
    final Map<String, ExpansionInfo> expansionInfo = new HashMap<>();
    formats.clear();
    for (ExpansionInfo set : ExpansionRepository.instance.getAll()) {
        expansionInfo.put(set.getName(), set);
        formats.add(set.getName());
        underlyingSetCodesPerFormat.put(set.getName(), new ArrayList<>());
        underlyingSetCodesPerFormat.get(set.getName()).add(set.getCode());
        if (set.getType() == SetType.CUSTOM_SET) {
            underlyingSetCodesPerFormat.get(CUSTOM).add(set.getCode());
            continue;
        }
        underlyingSetCodesPerFormat.get(VINTAGE_LEGACY).add(set.getCode());
        if (set.getType() == SetType.CORE || set.getType() == SetType.EXPANSION || set.getType() == SetType.SUPPLEMENTAL_STANDARD_LEGAL) {
            if (STANDARD_CARDS.getSetCodes().contains(set.getCode())) {
                underlyingSetCodesPerFormat.get(STANDARD).add(set.getCode());
            }
            if (set.getReleaseDate().after(extendedDate)) {
                underlyingSetCodesPerFormat.get(EXTENDED).add(set.getCode());
            }
            if (set.getReleaseDate().after(frontierDate)) {
                underlyingSetCodesPerFormat.get(FRONTIER).add(set.getCode());
            }
            if (set.getReleaseDate().after(modernDate)) {
                underlyingSetCodesPerFormat.get(MODERN).add(set.getCode());
            }
        }
        if (set.getType() == SetType.EXPANSION && set.getBlockName() != null) {
            String blockDisplayName = getBlockDisplayName(set.getBlockName());
            underlyingSetCodesPerFormat.computeIfAbsent(blockDisplayName, k -> new ArrayList<>());
            underlyingSetCodesPerFormat.get(blockDisplayName).add(set.getCode());
            if (expansionInfo.get(blockDisplayName) == null) {
                expansionInfo.put(blockDisplayName, set);
                formats.add(blockDisplayName);
            }
            if (expansionInfo.get(blockDisplayName).getReleaseDate().after(set.getReleaseDate())) {
                expansionInfo.put(blockDisplayName, set);
            }
        }
        if (set.getType() == SetType.SUPPLEMENTAL && set.getBlockName() != null) {
            expansionInfo.putIfAbsent(set.getBlockName(), set);
            if (expansionInfo.get(set.getBlockName()).getReleaseDate().before(set.getReleaseDate())) {
                expansionInfo.put(set.getBlockName(), set);
            }
        }
    }
    formats.sort((name1, name2) -> {
        ExpansionInfo expansionInfo1 = expansionInfo.get(name1);
        ExpansionInfo expansionInfo2 = expansionInfo.get(name2);
        if (expansionInfo1.getType().compareTo(expansionInfo2.getType()) == 0) {
            SetType setType = expansionInfo1.getType();
            switch(setType) {
                case EXPANSION:
                    if (expansionInfo1.getBlockName() == null) {
                        if (expansionInfo2.getBlockName() == null) {
                            return expansionInfo2.getReleaseDate().compareTo(expansionInfo1.getReleaseDate());
                        }
                        return 1;
                    }
                    if (expansionInfo2.getBlockName() == null) {
                        return -1;
                    }
                    if (name1.endsWith("String_Node_Str") && name2.endsWith("String_Node_Str")) {
                        return expansionInfo2.getReleaseDate().compareTo(expansionInfo1.getReleaseDate());
                    }
                    if (name1.endsWith("String_Node_Str")) {
                        if (expansionInfo1.getBlockName().equals(expansionInfo2.getBlockName())) {
                            return -1;
                        }
                    }
                    if (name2.endsWith("String_Node_Str")) {
                        if (expansionInfo1.getBlockName().equals(expansionInfo2.getBlockName())) {
                            return 1;
                        }
                    }
                    return expansionInfo2.getReleaseDate().compareTo(expansionInfo1.getReleaseDate());
                case SUPPLEMENTAL:
                    if (expansionInfo1.getBlockName() == null) {
                        if (expansionInfo2.getBlockName() == null) {
                            return expansionInfo2.getReleaseDate().compareTo(expansionInfo1.getReleaseDate());
                        }
                        return -1;
                    }
                    if (expansionInfo2.getBlockName() == null) {
                        return 1;
                    }
                    if (expansionInfo1.getBlockName().equals(expansionInfo2.getBlockName())) {
                        if (expansionInfo2.getReleaseDate().compareTo(expansionInfo1.getReleaseDate()) == 0) {
                            return name1.compareTo(name2);
                        }
                        return expansionInfo2.getReleaseDate().compareTo(expansionInfo1.getReleaseDate());
                    }
                    if (expansionInfo1.getBlockName().startsWith("String_Node_Str")) {
                        if (expansionInfo1.getBlockName().startsWith("String_Node_Str")) {
                            return 1;
                        }
                        return 1;
                    }
                    if (expansionInfo2.getBlockName().startsWith("String_Node_Str")) {
                        return -1;
                    }
                    ExpansionInfo blockInfo1 = expansionInfo.get(expansionInfo1.getBlockName());
                    ExpansionInfo blockInfo2 = expansionInfo.get(expansionInfo2.getBlockName());
                    return blockInfo2.getReleaseDate().compareTo(blockInfo1.getReleaseDate());
                default:
                    return expansionInfo2.getReleaseDate().compareTo(expansionInfo1.getReleaseDate());
            }
        }
        return expansionInfo1.getType().compareTo(expansionInfo2.getType());
    });
    if (!formats.isEmpty()) {
        formats.add(0, CUSTOM);
        formats.add(0, VINTAGE_LEGACY);
        formats.add(0, MODERN);
        formats.add(0, EXTENDED);
        formats.add(0, FRONTIER);
        formats.add(0, STANDARD);
    }
    formats.add(0, ALL);
}

Output:
             }
-            if (set.getReleaseDate().after(extendedDate)) {
-                underlyingSetCodesPerFormat.get(EXTENDED).add(set.getCode());
-            }
-            if (set.getReleaseDate().after(frontierDate)) {
-                underlyingSetCodesPerFormat.get(FRONTIER).add(set.getCode());
-            }
-            if (set.getReleaseDate().after(modernDate)) {
-                underlyingSetCodesPerFormat.get(MODERN).add(set.getCode());
+            if (set.getType() != SetType.SUPPLEMENTAL_STANDARD_LEGAL) {
+                if (set.getReleaseDate().after(extendedDate) && (set.getType() == SetType.EXPANSION || set.getType() == SetType.CORE)) {
+                    underlyingSetCodesPerFormat.get(EXTENDED).add(set.getCode());
+                }
+                if (set.getReleaseDate().after(frontierDate) && (set.getType() == SetType.EXPANSION || set.getType() == SetType.CORE)) {
+                    underlyingSetCodesPerFormat.get(FRONTIER).add(set.getCode());
+                }
+                if (set.getReleaseDate().after(modernDate) && (set.getType() == SetType.EXPANSION || set.getType() == SetType.CORE)) {
+                    underlyingSetCodesPerFormat.get(MODERN).add(set.getCode());
+                }
             }


Input:
public static void main(String[] args) throws Exception {
    if (args.length < 2) {
        System.err.println("String_Node_Str");
        return;
    }
    XMLImporter in = new XMLImporter(new FileInputStream(args[0]));
    BinaryExporter out = new BinaryExporter(new FileOutputStream(args[1]));
    Object obj;
    while ((obj = in.readObject()) != null) {
        out.writeObject(obj);
    }
    in.close();
    out.close();
}

Output:
     BinaryExporter out = new BinaryExporter(new FileOutputStream(args[1]));
-    Object obj;
-    while ((obj = in.readObject()) != null) {
-        out.writeObject(obj);
+    try {
+        while (true) {
+            out.writeObject(in.readObject());
+        }
+    } catch (EOFException e) {
+    } finally {
+        in.close();
+        out.close();
     }


Input:
Drawable loadDrawable(TypedValue value, int id) throws NotFoundException {
    if (TRACE_FOR_PRELOAD) {
        if ((id >>> 24) == 0x1) {
            final String name = getResourceName(id);
            if (name != null)
                android.util.Log.d("String_Node_Str", name);
        }
    }
    boolean isColorDrawable = false;
    if (value.type >= TypedValue.TYPE_FIRST_COLOR_INT && value.type <= TypedValue.TYPE_LAST_COLOR_INT) {
        isColorDrawable = true;
    }
    final long key = isColorDrawable ? value.data : (((long) value.assetCookie) << 32) | value.data;
    Drawable dr = getCachedDrawable(isColorDrawable ? mColorDrawableCache : mDrawableCache, key);
    if (dr != null) {
        return dr;
    }
    Drawable.ConstantState cs = isColorDrawable ? sPreloadedColorDrawables.get(key) : (sPreloadedDensity == mConfiguration.densityDpi ? sPreloadedDrawables.get(key) : null);
    if (cs != null) {
        dr = cs.newDrawable(this);
    } else {
        if (isColorDrawable) {
            dr = new ColorDrawable(value.data);
        }
        if (dr == null) {
            if (value.string == null) {
                throw new NotFoundException("String_Node_Str" + value);
            }
            String file = value.string.toString();
            if (TRACE_FOR_MISS_PRELOAD) {
                if ((id >>> 24) == 0x1) {
                    final String name = getResourceName(id);
                    if (name != null)
                        android.util.Log.d(TAG, "String_Node_Str" + Integer.toHexString(id) + "String_Node_Str" + name + "String_Node_Str" + file);
                }
            }
            if (DEBUG_LOAD)
                Log.v(TAG, "String_Node_Str" + value.assetCookie + "String_Node_Str" + file);
            if (file.endsWith("String_Node_Str")) {
                Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, file);
                try {
                    XmlResourceParser rp = loadXmlResourceParser(file, id, value.assetCookie, "String_Node_Str");
                    dr = Drawable.createFromXml(this, rp);
                    rp.close();
                } catch (Exception e) {
                    Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
                    NotFoundException rnf = new NotFoundException("String_Node_Str" + file + "String_Node_Str" + Integer.toHexString(id));
                    rnf.initCause(e);
                    throw rnf;
                }
                Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
            } else {
                Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, file);
                try {
                    InputStream is = mAssets.openNonAsset(value.assetCookie, file, AssetManager.ACCESS_STREAMING);
                    dr = Drawable.createFromResourceStream(this, value, is, file, null);
                    is.close();
                } catch (Exception e) {
                    Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
                    NotFoundException rnf = new NotFoundException("String_Node_Str" + file + "String_Node_Str" + Integer.toHexString(id));
                    rnf.initCause(e);
                    throw rnf;
                }
                Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
            }
        }
    }
    if (dr != null) {
        dr.setChangingConfigurations(value.changingConfigurations);
        cs = dr.getConstantState();
        if (cs != null) {
            if (mPreloading) {
                if (verifyPreloadConfig(cs.getChangingConfigurations(), value.resourceId, "String_Node_Str")) {
                    if (isColorDrawable) {
                        sPreloadedColorDrawables.put(key, cs);
                    } else {
                        sPreloadedDrawables.put(key, cs);
                    }
                }
            } else {
                synchronized (mAccessLock) {
                    if (isColorDrawable) {
                        mColorDrawableCache.put(key, new WeakReference<Drawable.ConstantState>(cs));
                    } else {
                        mDrawableCache.put(key, new WeakReference<Drawable.ConstantState>(cs));
                    }
                }
            }
        }
    }
    return dr;
}

Output:
     }
-    Drawable.ConstantState cs = isColorDrawable ? sPreloadedColorDrawables.get(key) : (sPreloadedDensity == mConfiguration.densityDpi ? sPreloadedDrawables.get(key) : null);
+    final int layoutDirection = mConfiguration.getLayoutDirection();
+    Drawable.ConstantState cs = isColorDrawable ? sPreloadedColorDrawables.get(key) : (sPreloadedDensity == mConfiguration.densityDpi ? sPreloadedDrawables[layoutDirection].get(key) : null);
     if (cs != null) {


Input:
public ElValue make(Object obj) {
    if (obj instanceof ElValue)
        return (ElValue) obj;
    if (null == obj)
        return new NullElValue();
    if (obj instanceof Map<?, ?>)
        return new MapElValue((Map<?, ?>) obj);
    if (obj instanceof List<?>)
        return new ListElValue((List<?>) obj);
    if (obj instanceof Collection<?>)
        return new CollectionElValue((List<?>) obj);
    if (obj.getClass().isArray()) {
        return new ArrayElValue(obj);
    }
    Mirror<?> mirror = Mirror.me(obj);
    if (mirror.isStringLike())
        return new StringElValue(obj.toString());
    if (mirror.isLong())
        return new LongElValue((Long) obj);
    if (mirror.isIntLike())
        return new IntegerElValue((Integer) obj);
    if (mirror.isBoolean())
        return (Boolean) obj ? El.TRUE : El.FALSE;
    if (mirror.isFloat())
        return new FloatElValue((Float) obj);
    return new PojoElValue<Object>(obj);
}

Output:
     if (mirror.isLong())
-        return new LongElValue((Long) obj);
+        return new NumberElValue((Long) obj);
     if (mirror.isIntLike())


Input:
public int costBed() {
    int fillCount = 0;
    for (TrackBase track : tracks) {
        if (world.isAirBlock(track.getPos().down())) {
            fillCount += 1;
        }
    }
    return (int) ((int) (this.tracks.size() * 0.1) + (this.info.railBedFill ? fillCount : 0) * Config.BedCostMultiplier);
}

Output:
     for (TrackBase track : tracks) {
-        if (world.isAirBlock(track.getPos().down())) {
+        if (BlockUtil.canBeReplaced(world, track.getPos().down(), false)) {
             fillCount += 1;


Input:
public void lookupNonExistingVariant() {
    AndroidVariant variant = (AndroidVariant) variantDao.findByVariantIDForDeveloper("String_Node_Str", "String_Node_Str");
    assertThat(variant).isNull();
}

Output:
 public void lookupNonExistingVariant() {
-    AndroidVariant variant = (AndroidVariant) variantDao.findByVariantIDForDeveloper("String_Node_Str", "String_Node_Str");
+    AndroidVariant variant = (AndroidVariant) variantDao.findByVariantID("String_Node_Str");
     assertThat(variant).isNull();


Input:
public void inc(int value) {
    totalCount += value;
}

Output:
 public void inc(int value) {
-    totalCount += value;
+    if (running)
+        totalCount += value;
 }


Input:
public void preInit(FMLPreInitializationEvent event) {
    NetworkRegistry.INSTANCE.registerGuiHandler(this, proxy);
    Modstats.instance().getReporter().registerMod(INSTANCE);
    MinecraftForge.EVENT_BUS.register(INSTANCE);
    modproxies.applyModule(Waila.class, true);
    Settings.CONFIGURATION.load();
    blockSulfurOre = contentRegistry.newBlock(BlockSulfurOre.class);
    blockGlassPlate = contentRegistry.newBlock("String_Node_Str", new BlockPressurePlate("String_Node_Str", Material.glass, BlockPressurePlate.Sensitivity.everything));
    blockGlassButton = contentRegistry.newBlock("String_Node_Str", new BlockButton(false));
    blockProximityDetector = contentRegistry.newBlock(TileProximityDetector.class);
    blockSpikes = contentRegistry.newBlock(BlockSpikes.class, ItemBlockMetadata.class);
    blockCamo = contentRegistry.newBlock(BlockCamouflage.class);
    blockConcrete = contentRegistry.newBlock(BlockConcrete.class, ItemBlockMetadata.class);
    blockReinforcedGlass = contentRegistry.newBlock(BlockReinforcedGlass.class, ItemBlockMetadata.class);
    blockCombatRail = contentRegistry.newBlock(BlockReinforcedRail.class);
    itemPoisonPowder = contentRegistry.newItem(ItemPoisonPowder.class);
    itemSulfurDust = contentRegistry.newItem(ItemSulfurDust.class);
    itemAntidote = contentRegistry.newItem(ItemAntidote.class);
    itemSignalDisrupter = contentRegistry.newItem(ItemSignalDisrupter.class);
    itemTracker = contentRegistry.newItem(ItemTracker.class);
    itemHackingComputer = contentRegistry.newItem(ItemComputer.class);
    if (OreDictionary.getOres("String_Node_Str").size() > 0) {
        blockRadioactive = Block.getBlockFromItem(OreDictionary.getOres("String_Node_Str").get(0).getItem());
        LOGGER.fine("String_Node_Str");
    } else {
        blockRadioactive = Blocks.mycelium;
    }
    Blocks.obsidian.setResistance(Settings.CONFIGURATION.get(Configuration.CATEGORY_GENERAL, "String_Node_Str", 45).getInt(45));
    LOGGER.fine("String_Node_Str" + Blocks.obsidian.getExplosionResistance(null));
    OreDictionary.registerOre("String_Node_Str", new ItemStack(itemSulfurDust, 1, 0));
    OreDictionary.registerOre("String_Node_Str", new ItemStack(itemSulfurDust, 1, 1));
    if (!Loader.isModLoaded("String_Node_Str") && !Loader.isModLoaded("String_Node_Str"))
        TabICBM.itemStack = new ItemStack(blockProximityDetector);
    proxy.preInit();
    modproxies.preInit();
}

Output:
     blockSpikes = contentRegistry.newBlock(BlockSpikes.class, ItemBlockMetadata.class);
-    blockCamo = contentRegistry.newBlock(BlockCamouflage.class);
+    blockCamo = contentRegistry.newBlock(TileCamouflage.class);
     blockConcrete = contentRegistry.newBlock(BlockConcrete.class, ItemBlockMetadata.class);