Input:
public Token one() throws IllegalActionException {
    Set labelSet = _fields.keySet();
    int size = labelSet.size();
    String[] labels = new String[size];
    Token[] values = new Token[size];
    Iterator iter = labelSet.iterator();
    int i = 0;
    while (iter.hasNext()) {
        labels[i] = (String) iter.next();
        values[i] = this.get(labels[i]).one();
    }
    return new RecordToken(labels, values);
}

Output:
 public Token one() throws IllegalActionException {
-    Set labelSet = _fields.keySet();
-    int size = labelSet.size();
-    String[] labels = new String[size];
-    Token[] values = new Token[size];
-    Iterator iter = labelSet.iterator();
-    int i = 0;
-    while (iter.hasNext()) {
-        labels[i] = (String) iter.next();
+    Object[] labelsObj = _fields.keySet().toArray();
+    String[] labels = new String[labelsObj.length];
+    Token[] values = new Token[labels.length];
+    for (int i = 0; i < labels.length; i++) {
+        labels[i] = (String) labelsObj[i];
         values[i] = this.get(labels[i]).one();


Input:
public void onClick(View v) {
    loadPage();
}

Output:
 public void onClick(View v) {
-    loadPage();
+    webView.reload();
 }


Input:
public void materialDelivered(RequestStack stack) {
    super.grid.requestSoldierable(Barrack.this);
}

Output:
 public void materialDelivered(RequestStack stack) {
-    super.grid.requestSoldierable(Barrack.this);
+    super.grid.requestSoldierable(this);
 }


Input:
public IPipeTile getPipe() {
    if (pipe == null) {
        pipe = (IPipeTile) world.getTileEntity(x(), y(), z());
    }
    if (pipe == null || ((TileEntity) pipe).isInvalid()) {
        RobotManager.registryProvider.getRegistry(world).removeStation(this);
        pipe = null;
    }
    return pipe;
}

Output:
     if (pipe == null) {
-        pipe = (IPipeTile) world.getTileEntity(x(), y(), z());
+        pipe = (IPipeTile) world.getTileEntity(getPos());
     }


Input:
private void updateComponentsRenderState(AjaxRequestTarget target, String bgColor, String fgColor, String compFont, String compBorder, boolean isSelected, boolean ignoreStyles) {
    Iterator<? extends Component> it = getListContainer().iterator();
    while (it.hasNext()) {
        Component component = it.next();
        if (component.isVisibleInHierarchy()) {
            Component innerComponent = CellContainer.getContentsForCell(component);
            if (!ignoreStyles) {
                WebCellBasedView.this.applyStyleOnComponent(innerComponent, bgColor, fgColor, compFont, compBorder);
            }
            boolean innerComponentChanged = innerComponent instanceof IProviderStylePropertyChanges && ((IProviderStylePropertyChanges) innerComponent).getStylePropertyChanges().isChanged();
            if (((updateComponentRenderState(innerComponent, isSelected)) || (!ignoreStyles)) && target != null) {
                target.addComponent(innerComponent.getParent() instanceof CellContainer ? innerComponent.getParent() : innerComponent);
                WebEventExecutor.generateDragAttach(innerComponent, target.getHeaderResponse());
                if (!innerComponent.isVisible()) {
                    ((IProviderStylePropertyChanges) innerComponent).getStylePropertyChanges().setRendered();
                }
            } else if (innerComponentChanged) {
                ((IProviderStylePropertyChanges) innerComponent).getStylePropertyChanges().setRendered();
            }
        }
    }
}

Output:
             if (!ignoreStyles) {
-                WebCellBasedView.this.applyStyleOnComponent(innerComponent, bgColor, fgColor, compFont, compBorder);
+                WebCellBasedView.this.applyStyleOnComponent(innerComponent, bgColor, fgColor, compFont, listItemBorder);
             }


Input:
public String toJavaCode(TypeSymbol currentType) {
    String code = "String_Node_Str";
    boolean isParentMessageSend = false;
    boolean currentValueIsToken = false;
    if (literal != null) {
        if (literal.value.equals("String_Node_Str")) {
            code += "String_Node_Str";
            if (modifications.size() == 0 || (modifications.size() > 0 && modifications.get(0) instanceof CMessageSend)) {
                if (SymbolTable.is_mobile_actor) {
                    code += "String_Node_Str";
                }
            }
        } else if (literal.value.equals("String_Node_Str")) {
            if (modifications.size() > 0 && modifications.get(0) instanceof CMessageSend) {
                code += "String_Node_Str";
                if (SymbolTable.is_mobile_actor) {
                    code += "String_Node_Str";
                }
                isParentMessageSend = true;
            } else {
                code += "String_Node_Str";
            }
        } else if (literal.value.equals("String_Node_Str")) {
            code += "String_Node_Str";
        } else {
            code += literal.toJavaCode();
        }
    } else if (variable_name != null) {
        code += variable_name;
        try {
            currentValueIsToken = SymbolTable.isToken(variable_name.name);
        } catch (SalsaNotFoundException snfe) {
            CompilerErrors.printErrorMessage("String_Node_Str", variable_name);
            currentValueIsToken = false;
        }
    } else if (expression != null) {
        code += "String_Node_Str" + expression.toJavaCode() + "String_Node_Str";
        currentValueIsToken = expression.isToken();
    } else if (allocation != null) {
        code += allocation.toJavaCode();
        currentValueIsToken = allocation.isToken();
    }
    if (cast_type != null) {
        if (isToken()) {
            if (cast_type.is_token) {
                code = "String_Node_Str" + code;
            } else {
                CompilerErrors.printErrorMessage("String_Node_Str", cast_type);
            }
        } else {
            if (cast_type.is_token) {
                CompilerErrors.printErrorMessage("String_Node_Str", cast_type);
            } else {
                code = "String_Node_Str" + cast_type.name + "String_Node_Str" + code;
            }
        }
    }
    if (currentType == null)
        currentType = getValueType();
    int position = 0;
    for (CModification modification : modifications) {
        if (modification instanceof CArrayAccess) {
            CArrayAccess aa = (CArrayAccess) modification;
            if (aa.expression.isToken()) {
                System.err.println("String_Node_Str");
                CompilerErrors.printErrorMessage("String_Node_Str", aa);
                currentType = null;
            } else {
                code += "String_Node_Str" + aa.expression.toJavaCode() + "String_Node_Str";
                if (currentType == null) {
                    System.err.println("String_Node_Str");
                    throw new RuntimeException();
                }
                currentType = ((ArrayType) currentType).getSubtype();
            }
            if (aa.expression.isToken())
                currentValueIsToken = true;
        } else if (modification instanceof CFieldAccess) {
            CFieldAccess fa = (CFieldAccess) modification;
            if (currentType instanceof ObjectType) {
                code += "String_Node_Str" + fa.name;
                currentType = ((ObjectType) currentType).getFieldType(fa.name);
            } else if (currentType instanceof ActorType) {
                code += "String_Node_Str" + fa.name;
                currentType = ((ActorType) currentType).getFieldType(fa.name);
            } else if (currentType instanceof ArrayType) {
                code += "String_Node_Str" + fa.name;
                currentType = ((ArrayType) currentType).getFieldType(fa.name);
            } else if (currentType instanceof PrimitiveType) {
                CompilerErrors.printErrorMessage("String_Node_Str", fa);
                currentType = null;
            } else {
                CompilerErrors.printErrorMessage("String_Node_Str", fa);
                currentType = null;
            }
        } else if (modification instanceof CMethodInvocation) {
            CMethodInvocation mi = (CMethodInvocation) modification;
            try {
                if (currentType instanceof ObjectType) {
                    MethodSymbol ms = ((ObjectType) currentType).getMethod(mi.method_name, mi.arguments);
                    if (ms == null) {
                        CompilerErrors.printErrorMessage("String_Node_Str", mi);
                        currentType = null;
                    }
                    currentType = ms.getReturnType();
                } else if (currentType instanceof ActorType) {
                    if (modifications.getFirst().equals(modification) && (isSelf() || isParent() || SymbolTable.isReferenceMethod((CMethodInvocation) modification))) {
                        currentType = ((ActorType) currentType).getMessage(mi.method_name, mi.arguments, isParentMessageSend).getPassType();
                    } else {
                        CompilerErrors.printErrorMessage("String_Node_Str", mi);
                        currentType = null;
                    }
                } else if (currentType instanceof ArrayType) {
                    CompilerErrors.printErrorMessage("String_Node_Str", mi);
                    currentType = null;
                } else if (currentType instanceof PrimitiveType) {
                    CompilerErrors.printErrorMessage("String_Node_Str", mi);
                    currentType = null;
                } else {
                    CompilerErrors.printErrorMessage("String_Node_Str", mi);
                    currentType = null;
                }
                if (currentType != null) {
                    code += "String_Node_Str" + mi.method_name + "String_Node_Str";
                    for (CExpression argument : mi.arguments) {
                        if (!argument.isToken()) {
                            code += argument.toJavaCode();
                            if (!argument.equals(mi.arguments.lastElement()))
                                code += "String_Node_Str";
                        } else {
                            CompilerErrors.printErrorMessage("String_Node_Str", argument);
                        }
                    }
                    code += "String_Node_Str";
                }
            } catch (VariableDeclarationException vde) {
                CompilerErrors.printErrorMessage("String_Node_Str" + vde.toString(), mi);
                throw new RuntimeException(vde);
            } catch (SalsaNotFoundException snfe) {
                CompilerErrors.printErrorMessage("String_Node_Str" + snfe.toString(), mi);
                throw new RuntimeException(snfe);
            }
        } else if (modification instanceof CMessageSend) {
            CMessageSend ms = (CMessageSend) modification;
            try {
                String joinDirector = SymbolTable.getJoinDirector();
                if (ms.message_property != null && !ms.message_property.name.equals("String_Node_Str")) {
                    CompilerErrors.printErrorMessage("String_Node_Str" + ms.message_property.name + "String_Node_Str", ms);
                }
                boolean moreMessages = false;
                for (int new_pos = position + 1; new_pos < modifications.size(); new_pos++) {
                    if (modifications.get(new_pos) instanceof CMessageSend) {
                        moreMessages = true;
                        break;
                    }
                }
                String pre_code = "String_Node_Str";
                if (SymbolTable.continuesToPass && !SymbolTable.withinArguments) {
                    pre_code += "String_Node_Str";
                } else if (SymbolTable.withinArguments) {
                    pre_code += "String_Node_Str";
                } else if (SymbolTable.continuationTokenMessage) {
                    pre_code += "String_Node_Str";
                } else if (SymbolTable.isExpressionContinuation) {
                    pre_code += "String_Node_Str";
                } else if (SymbolTable.messageContinues || joinDirector != null) {
                    if (moreMessages) {
                        pre_code += "String_Node_Str";
                    } else {
                        if (SymbolTable.firstContinuation()) {
                            pre_code += "String_Node_Str";
                            SymbolTable.initializedFirstContinuation();
                        }
                        pre_code += "String_Node_Str";
                    }
                } else if (moreMessages) {
                    pre_code += "String_Node_Str";
                } else {
                    pre_code += "String_Node_Str";
                }
                String expression_director_code = "String_Node_Str";
                pre_code += "String_Node_Str";
                String target_code = code;
                if (currentType.isInterface)
                    target_code = "String_Node_Str" + target_code;
                if (currentValueIsToken) {
                    code = pre_code + "String_Node_Str";
                } else {
                    code = pre_code + target_code + "String_Node_Str";
                }
                if (!(currentType instanceof ActorType)) {
                    CompilerErrors.printErrorMessage("String_Node_Str" + currentType.getLongSignature() + "String_Node_Str", ms);
                    throw new RuntimeException();
                }
                ActorType at = (ActorType) currentType;
                MessageSymbol messageSymbol = null;
                try {
                    messageSymbol = at.getMessage(ms.message_name, ms.arguments, isParentMessageSend);
                } catch (VariableDeclarationException vde) {
                    CompilerErrors.printErrorMessage("String_Node_Str" + ms.message_name + "String_Node_Str" + vde.toString(), ms);
                    throw new RuntimeException(vde);
                } catch (SalsaNotFoundException snfe) {
                    CompilerErrors.printErrorMessage("String_Node_Str" + ms.message_name + "String_Node_Str", ms);
                    throw new RuntimeException(snfe);
                }
                code += messageSymbol.getId();
                code += "String_Node_Str" + ms.message_name + "String_Node_Str";
                String argument_code = "String_Node_Str";
                String argument_tokens = "String_Node_Str";
                boolean hasContinuationToken = false;
                boolean hasToken = false;
                int j = 0;
                for (CExpression argument : ms.arguments) {
                    if (argument.isToken()) {
                        if (argument.requiresExpressionDirector()) {
                            expression_director_code += argument.getExpressionDirectorCode();
                        }
                        if (argument_tokens.length() > 10)
                            argument_tokens += "String_Node_Str";
                        argument_tokens += j;
                        hasToken = true;
                    } else if (SymbolTable.isMutableObject(argument.getType())) {
                        argument_code += "String_Node_Str" + argument.getType().getName() + "String_Node_Str";
                    }
                    SymbolTable.withinArguments = true;
                    argument_code += argument.toJavaCode();
                    SymbolTable.withinArguments = false;
                    if (SymbolTable.isMutableObject(argument.getType()))
                        argument_code += "String_Node_Str";
                    if (!argument.equals(ms.arguments.lastElement()))
                        argument_code += "String_Node_Str";
                    j++;
                }
                code = expression_director_code + code;
                if (hasToken) {
                    argument_code += "String_Node_Str" + argument_tokens + "String_Node_Str";
                } else {
                    argument_code += "String_Node_Str";
                }
                if (ms.arguments.size() == 0)
                    argument_code = "String_Node_Str";
                code += argument_code;
                if (ms.message_property != null && ms.message_property.name.equals("String_Node_Str")) {
                    code += "String_Node_Str";
                    for (int i = 0; i < ms.message_property.arguments.size(); i++) {
                        CExpression arg = ms.message_property.arguments.get(i);
                        if (!arg.isToken()) {
                            CompilerErrors.printErrorMessage("String_Node_Str", arg);
                            throw new RuntimeException();
                        }
                        code += arg.toJavaCode();
                        if (i != ms.message_property.arguments.size() - 1)
                            code += "String_Node_Str";
                    }
                    if (SymbolTable.messageRequiresContinuation) {
                        code += "String_Node_Str";
                        SymbolTable.messageRequiresContinuation = false;
                    }
                    code += "String_Node_Str";
                } else if (SymbolTable.messageRequiresContinuation) {
                    code += "String_Node_Str";
                    SymbolTable.messageRequiresContinuation = false;
                }
                if (SymbolTable.continuesToPass && !SymbolTable.withinArguments) {
                    code += "String_Node_Str";
                }
                if (currentValueIsToken) {
                    code += "String_Node_Str" + target_code;
                }
                code += "String_Node_Str";
                if (joinDirector != null && !SymbolTable.messageContinues) {
                    code += "String_Node_Str";
                    code += CIndent.getIndent() + "String_Node_Str" + joinDirector + "String_Node_Str" + joinDirector + "String_Node_Str";
                }
                currentType = ((ActorType) currentType).getMessage(ms.message_name, ms.arguments, isParentMessageSend).getPassType();
                SymbolTable.setContinuationType(currentType);
            } catch (VariableDeclarationException vde) {
                CompilerErrors.printErrorMessage("String_Node_Str" + vde.toString(), ms);
                throw new RuntimeException(vde);
            } catch (SalsaNotFoundException snfe) {
                CompilerErrors.printErrorMessage("String_Node_Str" + snfe.toString(), ms);
                throw new RuntimeException(snfe);
            }
            currentValueIsToken = true;
        }
        isParentMessageSend = false;
        position++;
    }
    return code;
}

Output:
                     SymbolTable.withinArguments = false;
-                    if (SymbolTable.isMutableObject(argument.getType()))
+                    if (!argument.isToken() && SymbolTable.isMutableObject(argument.getType()))
                         argument_code += "String_Node_Str";


Input:
private void inferTypes(MarkerList markers) {
    if (!this.method.hasTypeVariables()) {
        for (int i = 0; i < this.parameterCount; i++) {
            IParameter param = this.parameters[i];
            if (param.getType() == Types.UNKNOWN) {
                param.setType(this.method.getParameter(i).getType());
            }
        }
        this.returnType = this.method.getType();
        return;
    }
    for (int i = 0; i < this.parameterCount; i++) {
        IParameter param = this.parameters[i];
        IType parType = param.getType();
        if (parType != Types.UNKNOWN) {
            continue;
        }
        IType methodParamType = this.method.getParameter(i).getType();
        IType concreteType = methodParamType.getConcreteType(this.type).getParameterType();
        if (concreteType == methodParamType && concreteType.hasTypeVariables()) {
            markers.add(param.getPosition(), "String_Node_Str", param.getName());
        }
        param.setType(concreteType);
    }
    this.returnType = this.method.getType().getConcreteType(this.type).getReturnType();
    return;
}

Output:
         IParameter param = this.parameters[i];
-        IType parType = param.getType();
-        if (parType != Types.UNKNOWN) {
+        if (param.getType() != Types.UNKNOWN) {
             continue;


Input:
public void testWorkflowScopedArguments() throws Exception {
    String workflowAppWithScopedParameters = "String_Node_Str";
    String workflowAppWithScopedParameterWorkflow = "String_Node_Str";
    HttpResponse response = deploy(WorkflowAppWithScopedParameters.class, Constants.Gateway.API_VERSION_3_TOKEN, TEST_NAMESPACE2);
    Assert.assertEquals(200, response.getStatusLine().getStatusCode());
    Id.Program programId = Id.Program.from(TEST_NAMESPACE2, workflowAppWithScopedParameters, ProgramType.WORKFLOW, workflowAppWithScopedParameterWorkflow);
    Map<String, String> runtimeArguments = Maps.newHashMap();
    runtimeArguments.put("String_Node_Str", "String_Node_Str");
    runtimeArguments.put("String_Node_Str", "String_Node_Str");
    runtimeArguments.put("String_Node_Str", "String_Node_Str");
    runtimeArguments.put("String_Node_Str", createInput("String_Node_Str"));
    runtimeArguments.put("String_Node_Str", createInput("String_Node_Str"));
    runtimeArguments.put("String_Node_Str", createInput("String_Node_Str"));
    runtimeArguments.put("String_Node_Str", createInput("String_Node_Str"));
    runtimeArguments.put("String_Node_Str", new File(tmpFolder.newFolder(), "String_Node_Str").getAbsolutePath());
    runtimeArguments.put("String_Node_Str", new File(tmpFolder.newFolder(), "String_Node_Str").getAbsolutePath());
    runtimeArguments.put("String_Node_Str", new File(tmpFolder.newFolder(), "String_Node_Str").getAbsolutePath());
    runtimeArguments.put("String_Node_Str", "String_Node_Str");
    runtimeArguments.put("String_Node_Str", "String_Node_Str");
    runtimeArguments.put("String_Node_Str", "String_Node_Str");
    runtimeArguments.put("String_Node_Str", "String_Node_Str");
    runtimeArguments.put("String_Node_Str", "String_Node_Str");
    setAndTestRuntimeArgs(programId, runtimeArguments);
    startProgram(programId);
    verifyProgramRuns(programId, "String_Node_Str");
    List<RunRecord> workflowHistoryRuns = getProgramRuns(programId, "String_Node_Str");
    Id.Program mr1ProgramId = Id.Program.from(TEST_NAMESPACE2, workflowAppWithScopedParameters, ProgramType.MAPREDUCE, "String_Node_Str");
    List<RunRecord> oneMRHistoryRuns = getProgramRuns(mr1ProgramId, "String_Node_Str");
    Id.Program mr2ProgramId = Id.Program.from(TEST_NAMESPACE2, workflowAppWithScopedParameters, ProgramType.MAPREDUCE, "String_Node_Str");
    List<RunRecord> anotherMRHistoryRuns = getProgramRuns(mr2ProgramId, "String_Node_Str");
    Id.Program spark1ProgramId = Id.Program.from(TEST_NAMESPACE2, workflowAppWithScopedParameters, ProgramType.SPARK, "String_Node_Str");
    List<RunRecord> oneSparkHistoryRuns = getProgramRuns(spark1ProgramId, "String_Node_Str");
    Id.Program spark2ProgramId = Id.Program.from(TEST_NAMESPACE2, workflowAppWithScopedParameters, ProgramType.SPARK, "String_Node_Str");
    List<RunRecord> anotherSparkHistoryRuns = getProgramRuns(spark2ProgramId, "String_Node_Str");
    Assert.assertEquals(1, workflowHistoryRuns.size());
    Assert.assertEquals(1, oneMRHistoryRuns.size());
    Assert.assertEquals(1, anotherMRHistoryRuns.size());
    Assert.assertEquals(1, oneSparkHistoryRuns.size());
    Assert.assertEquals(1, anotherSparkHistoryRuns.size());
    Map<String, String> workflowRunRecordProperties = workflowHistoryRuns.get(0).getProperties();
    Map<String, String> oneMRRunRecordProperties = oneMRHistoryRuns.get(0).getProperties();
    Map<String, String> anotherMRRunRecordProperties = anotherMRHistoryRuns.get(0).getProperties();
    Map<String, String> oneSparkRunRecordProperties = oneSparkHistoryRuns.get(0).getProperties();
    Map<String, String> anotherSparkRunRecordProperties = anotherSparkHistoryRuns.get(0).getProperties();
    Assert.assertNotNull(oneMRRunRecordProperties.get("String_Node_Str"));
    Assert.assertEquals(workflowHistoryRuns.get(0).getPid(), oneMRRunRecordProperties.get("String_Node_Str"));
    Assert.assertNotNull(anotherMRRunRecordProperties.get("String_Node_Str"));
    Assert.assertEquals(workflowHistoryRuns.get(0).getPid(), anotherMRRunRecordProperties.get("String_Node_Str"));
    Assert.assertNotNull(oneSparkRunRecordProperties.get("String_Node_Str"));
    Assert.assertEquals(workflowHistoryRuns.get(0).getPid(), oneSparkRunRecordProperties.get("String_Node_Str"));
    Assert.assertNotNull(anotherSparkRunRecordProperties.get("String_Node_Str"));
    Assert.assertEquals(workflowHistoryRuns.get(0).getPid(), anotherSparkRunRecordProperties.get("String_Node_Str"));
    Assert.assertEquals(workflowRunRecordProperties.get("String_Node_Str"), oneMRHistoryRuns.get(0).getPid());
    Assert.assertEquals(workflowRunRecordProperties.get("String_Node_Str"), oneSparkHistoryRuns.get(0).getPid());
    Assert.assertEquals(workflowRunRecordProperties.get("String_Node_Str"), anotherMRHistoryRuns.get(0).getPid());
    Assert.assertEquals(workflowRunRecordProperties.get("String_Node_Str"), anotherSparkHistoryRuns.get(0).getPid());
}

Output:
     startProgram(programId);
-    verifyProgramRuns(programId, "String_Node_Str");
+    waitState(programId, "String_Node_Str");
     List<RunRecord> workflowHistoryRuns = getProgramRuns(programId, "String_Node_Str");


Input:
private boolean _matchList(LookbackEntry matchedObjectLists) {
    ObjectList patternList = matchedObjectLists.getPatternList();
    ObjectList hostList = matchedObjectLists.getHostList();
    int matchSize = _matchResult.size();
    boolean success = true;
    boolean patternChildChecked = false;
    boolean firstEntrance = !_matchResult.containsKey(patternList);
    FastLinkedList<LookbackEntry>.Entry lookbackTail = null;
    if (firstEntrance) {
        _matchResult.put(patternList, hostList);
        _lookbackList.add(matchedObjectLists);
        lookbackTail = _lookbackList.getTail();
    }
    ObjectList.Entry patternEntry = patternList.getHead();
    Object patternObject = null;
    while (patternEntry != null) {
        patternObject = patternEntry.getValue();
        if (_negation == _isNegated(patternObject) && !_isIgnored(patternObject)) {
            break;
        }
        patternEntry = patternEntry.getNext();
    }
    boolean optional = false;
    if (patternEntry != null) {
        ObjectList.Entry previous = patternEntry.getPrevious();
        patternEntry.remove();
        optional = _isOptional(patternObject);
        if (optional && !_ignoredOptionalObjects.containsKey(patternObject)) {
            _ignoredOptionalObjects.put(patternObject, false);
        } else {
            optional = false;
        }
        patternChildChecked = true;
        success = false;
        ObjectList.Entry hostEntryPrevious = null;
        ObjectList.Entry hostEntry = hostList.getHead();
        while (hostEntry != null) {
            hostEntry.remove();
            Object hostObject = hostEntry.getValue();
            if (_matchObject(patternObject, hostObject)) {
                success = true;
            }
            hostList.addEntryAfter(hostEntry, hostEntryPrevious);
            if (success) {
                break;
            }
            hostEntryPrevious = hostEntry;
            hostEntry = hostEntry.getNext();
        }
        patternList.addEntryAfter(patternEntry, previous);
    }
    if (success) {
        if (!patternChildChecked) {
            if (_negation) {
                matchedObjectLists.setNegated(true);
            } else {
                matchedObjectLists.setFinished(true);
            }
            success = _checkBackward();
            if (_negation) {
                matchedObjectLists.setNegated(false);
            } else {
                matchedObjectLists.setFinished(false);
            }
        }
    }
    if (success == _negation) {
        if (!success || optional) {
            _matchResult.retain(matchSize);
        }
        if (optional) {
            _ignoredOptionalObjects.put(patternObject, true);
            ObjectList.Entry previous = patternEntry.getPrevious();
            patternEntry.remove();
            success = _checkBackward();
            patternList.addEntryAfter(patternEntry, previous);
        }
    }
    if (firstEntrance) {
        lookbackTail.remove();
    }
    if (optional) {
        _ignoredOptionalObjects.remove(patternObject);
    }
    return success;
}

Output:
     }
-    boolean optional = false;
+    NamedObj optionalContainer = null;
     if (patternEntry != null) {


Input:
public static BigDecimal libilityToStake(BigDecimal liability, BigDecimal price) {
    return liability.divide(price.subtract(BigDecimal.ONE));
}

Output:
 public static BigDecimal libilityToStake(BigDecimal liability, BigDecimal price) {
-    return liability.divide(price.subtract(BigDecimal.ONE));
+    return liability.divide(price.subtract(BigDecimal.ONE), BigDecimal.ROUND_HALF_UP);
 }


Input:
public static void main(String[] args) throws FileNotFoundException {
    countAndPersistDBpediaGraphOccs();
}

Output:
 public static void main(String[] args) throws FileNotFoundException {
-    countAndPersistDBpediaGraphOccs();
+    Graph graph = GraphFactory.getDBpediaGraph();
+    countAndPersistDBpediaGraphOccs(graph);
+    graph.shutdown();
 }


Input:
public String get(String outputDir) {
    if (outputDir == null) {
        outputDir = DEFAULT_OUTPUT_DIR;
    }
    baseDirectory = new File(outputDir);
    baseDirectory.mkdirs();
    String retVal = "String_Node_Str" + outputDir + "String_Node_Str";
    try {
        generateClasses();
    } catch (Exception ex) {
        Logger.getLogger(GeneratorResource.class.getName()).log(Level.SEVERE, null, ex);
        retVal = "String_Node_Str" + ex.toString() + "String_Node_Str";
    }
    return retVal;
}

Output:
     baseDirectory = new File(outputDir);
-    baseDirectory.mkdirs();
-    String retVal = "String_Node_Str" + outputDir + "String_Node_Str";
-    try {
-        generateClasses();
-    } catch (Exception ex) {
-        Logger.getLogger(GeneratorResource.class.getName()).log(Level.SEVERE, null, ex);
-        retVal = "String_Node_Str" + ex.toString() + "String_Node_Str";
+    boolean success = baseDirectory.mkdirs();
+    if (success) {
+        try {
+            generateClasses();
+        } catch (Exception ex) {
+            Logger.getLogger(GeneratorResource.class.getName()).log(Level.SEVERE, null, ex);
+            retVal = "String_Node_Str" + ex.toString() + "String_Node_Str";
+        }
+    } else {
+        retVal = "String_Node_Str";
     }


Input:
private void paintText(Canvas canvas) {
    List<SchoolClass> schoolClasses = lesson.getSchoolClasses();
    List<SchoolRoom> schoolRooms = lesson.getSchoolRooms();
    List<SchoolSubject> schoolSubjects = lesson.getSchoolSubjects();
    List<SchoolTeacher> schoolTeachers = lesson.getSchoolTeachers();
    TextPaint tp = new TextPaint();
    tp.setColor(Color.BLACK);
    tp.setAntiAlias(true);
    tp.setTextSize(30);
    StringBuilder classes = new StringBuilder();
    StringBuilder rooms = new StringBuilder();
    StringBuilder subjects = new StringBuilder();
    StringBuilder teacher = new StringBuilder();
    for (SchoolClass s : schoolClasses) {
        classes.append(s.getName() + "String_Node_Str");
    }
    for (SchoolRoom s : schoolRooms) {
        rooms.append(s.getName() + "String_Node_Str");
    }
    for (SchoolSubject s : schoolSubjects) {
        subjects.append(s.getName() + "String_Node_Str");
    }
    for (SchoolTeacher s : schoolTeachers) {
        teacher.append(s.getName() + "String_Node_Str");
    }
    if (lcode instanceof LessonCodeSubstitute) {
        LessonCodeSubstitute lcs = (LessonCodeSubstitute) lcode;
        SchoolRoom originSchoolRoom = lcs.getOriginSchoolRoom();
        SchoolTeacher originSchoolTeacher = lcs.getOriginSchoolTeacher();
        if (originSchoolRoom != null)
            rooms.append("String_Node_Str" + originSchoolRoom.getName() + "String_Node_Str");
        if (originSchoolTeacher != null)
            teacher.append("String_Node_Str" + originSchoolTeacher.getName() + "String_Node_Str");
    }
    StaticLayout sl = new StaticLayout(classes.toString(), tp, width, Layout.Alignment.ALIGN_CENTER, 0, 0, false);
    canvas.translate(0, 40);
    sl.draw(canvas);
    sl = new StaticLayout(teacher.toString(), tp, width, Layout.Alignment.ALIGN_CENTER, 0, 0, false);
    canvas.translate(0, 40);
    sl.draw(canvas);
    sl = new StaticLayout(subjects.toString(), tp, width, Layout.Alignment.ALIGN_CENTER, 0, 0, false);
    canvas.translate(0, 40);
    sl.draw(canvas);
    sl = new StaticLayout(rooms.toString(), tp, width, Layout.Alignment.ALIGN_CENTER, 0, 0, false);
    canvas.translate(0, 40);
    sl.draw(canvas);
}

Output:
     for (SchoolClass s : schoolClasses) {
-        classes.append(s.getName() + "String_Node_Str");
+        classes.append(s.getName().trim() + "String_Node_Str");
     }


Input:
public String[] getFrameworkProgramArguments(IPath configPath, boolean debug, boolean starting) {
    return new String[] { "String_Node_Str" + configPath.append("String_Node_Str").makeAbsolute().toOSString() };
}

Output:
 public String[] getFrameworkProgramArguments(IPath configPath, boolean debug, boolean starting) {
-    return new String[] { "String_Node_Str" + configPath.append("String_Node_Str").makeAbsolute().toOSString() };
+    return new String[] { configPath.append("String_Node_Str").makeAbsolute().toPortableString() };
 }


Input:
public Node createEditorVBox(WebView webView) {
    VBox vbox = new VBox();
    MenuBar menuBar = new MenuBar();
    menuBar.getStyleClass().add("String_Node_Str");
    String iconSize = "String_Node_Str";
    double minSize = 14.01;
    Label saveLabel = LabelBuilt.icon(AwesomeIcon.SAVE, iconSize, minSize).tip("String_Node_Str").click(controller::saveDoc).build();
    Label newLabel = LabelBuilt.icon(AwesomeIcon.FILE_TEXT_ALT, iconSize, minSize).tip("String_Node_Str").click(controller::newDoc).build();
    Label openLabel = LabelBuilt.icon(AwesomeIcon.FOLDER_ALTPEN_ALT, iconSize, minSize).tip("String_Node_Str").click(controller::openDoc).build();
    Label boldLabel = LabelBuilt.icon(AwesomeIcon.BOLD, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label italicLabel = LabelBuilt.icon(AwesomeIcon.ITALIC, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label headerLabel = LabelBuilt.icon(AwesomeIcon.ITALIC, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label codeLabel = LabelBuilt.icon(AwesomeIcon.CODE, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label ulListLabel = LabelBuilt.icon(AwesomeIcon.LIST_UL, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label olListLabel = LabelBuilt.icon(AwesomeIcon.LIST_ALTL, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label tableLabel = LabelBuilt.icon(AwesomeIcon.TABLE, iconSize, minSize).tip("String_Node_Str").click(controller::createTable).build();
    Label imageLabel = LabelBuilt.icon(AwesomeIcon.IMAGE, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label subscriptLabel = LabelBuilt.icon(AwesomeIcon.SUBSCRIPT, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label superScriptLabel = LabelBuilt.icon(AwesomeIcon.SUPERSCRIPT, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label underlineLabel = LabelBuilt.icon(AwesomeIcon.UNDERLINE, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label hyperlinkLabel = LabelBuilt.icon(AwesomeIcon.LINK, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label strikethroughLabel = LabelBuilt.icon(AwesomeIcon.STRIKETHROUGH, iconSize, minSize).tip("String_Node_Str").click(event -> {
        current.currentEngine().executeScript("String_Node_Str");
    }).build();
    Label openMenuLabel = LabelBuilt.icon(AwesomeIcon.CHEVRON_CIRCLE_DOWN, iconSize, minSize).tip("String_Node_Str").build();
    openMenuLabel.setOnMouseClicked(event -> {
        int childSize = vbox.getChildren().size();
        if (childSize == 2) {
            openMenuLabel.setText(AwesomeIcon.CHEVRON_CIRCLE_DOWN.toString());
            Tooltip.install(openMenuLabel, new Tooltip("String_Node_Str"));
            vbox.getChildren().remove(1);
        } else {
            openMenuLabel.setText(AwesomeIcon.CHEVRON_CIRCLE_UP.toString());
            openMenuLabel.getProperties().clear();
            vbox.getChildren().add(createSecondEditorVBox(iconSize));
        }
    });
    menuBar.getMenus().addAll(new Menu("String_Node_Str", newLabel), new Menu("String_Node_Str", openLabel), new Menu("String_Node_Str", saveLabel), new Menu("String_Node_Str", boldLabel), new Menu("String_Node_Str", italicLabel), new Menu("String_Node_Str", underlineLabel), new Menu("String_Node_Str", strikethroughLabel), new Menu("String_Node_Str", headerLabel), new Menu("String_Node_Str", hyperlinkLabel), new Menu("String_Node_Str", codeLabel), new Menu("String_Node_Str", ulListLabel), new Menu("String_Node_Str", olListLabel), new Menu("String_Node_Str", tableLabel), new Menu("String_Node_Str", imageLabel), new Menu("String_Node_Str", subscriptLabel), new Menu("String_Node_Str", superScriptLabel), new Menu("String_Node_Str", openMenuLabel));
    ScrollPane scrollPane = new ScrollPane();
    scrollPane.setContent(webView);
    scrollPane.setFitToHeight(true);
    scrollPane.setFitToWidth(true);
    VBox.setVgrow(scrollPane, Priority.ALWAYS);
    vbox.getChildren().add(menuBar);
    return new VBox(vbox, scrollPane);
}

Output:
     }).build();
-    Label headerLabel = LabelBuilt.icon(AwesomeIcon.ITALIC, iconSize, minSize).tip("String_Node_Str").click(event -> {
+    Label headerLabel = LabelBuilt.icon(AwesomeIcon.HEADER, iconSize, minSize).tip("String_Node_Str").click(event -> {
         current.currentEngine().executeScript("String_Node_Str");


Input:
private boolean checkTargetReconnection() {
    if (newTarget.equals(oldSource)) {
        return false;
    }
    for (Iterator<?> iter = newTarget.getTargetConnections().iterator(); iter.hasNext(); ) {
        Connection conn = (Connection) iter.next();
        if (conn.getSource().equals(oldSource) && !conn.equals(connection)) {
            return false;
        }
    }
    return true;
}

Output:
         Connection conn = (Connection) iter.next();
-        if (conn.getSource().equals(oldSource) && !conn.equals(connection)) {
+        if (conn != null && conn.getSource().equals(oldSource) && !conn.equals(connection)) {
             return false;


Input:
public void before() throws Exception {
    SSHClient hadoopCli = new SSHClient(getHadoopCliHostname(), getHadoopCliUsername(), getHadoopCliPassword(), null);
    removeHdfsDir(hadoopCli, mrOutputDir1);
    removeHdfsDir(hadoopCli, mrOutputDir2);
    MetadataManager.removeInstance(KylinConfig.getInstanceFromEnv());
    CubeManager.removeInstance(KylinConfig.getInstanceFromEnv());
    ProjectManager.removeInstance(KylinConfig.getInstanceFromEnv());
}

Output:
 public void before() throws Exception {
-    SSHClient hadoopCli = new SSHClient(getHadoopCliHostname(), getHadoopCliUsername(), getHadoopCliPassword(), null);
+    SSHClient hadoopCli = new SSHClient(getHadoopCliHostname(), getHadoopCliUsername(), getHadoopCliPassword());
     removeHdfsDir(hadoopCli, mrOutputDir1);


Input:
private void restoreControlFlowPass(ConstantPool constants, MethodBody body, boolean secondpass) {
    try {
        HashMap<Integer, List<Integer>> refs;
        int[] visited2 = new int[code.size()];
        refs = visitCode(body);
        HashMap<Integer, List<Object>> appended = new HashMap<>();
        {
            restoreControlFlow(0, refs, visited2, appended);
            for (ABCException e : body.exceptions) {
                try {
                    restoreControlFlow(adr2pos(e.start), refs, visited2, appended);
                    restoreControlFlow(adr2pos(e.target), refs, visited2, appended);
                    restoreControlFlow(adr2pos(e.end), refs, visited2, appended);
                } catch (ConvertException ex) {
                    Logger.getLogger(AVM2Code.class.getName()).log(Level.FINE, null, ex);
                }
            }
        }
        for (int ip : appended.keySet()) {
            code.get(ip).replaceWith = appended.get(ip);
        }
    } catch (ConvertException cex) {
        cex.printStackTrace();
    }
    invalidateCache();
    try {
        List<Integer> outputMap = new ArrayList<>();
        String src = Highlighting.stripHilights(toASMSource(constants, body, outputMap, false));
        AVM2Code acode = ASM3Parser.parse(new ByteArrayInputStream(src.getBytes("String_Node_Str")), constants, null, body);
        for (int i = 0; i < acode.code.size(); i++) {
            if (outputMap.size() > i) {
                int tpos = outputMap.get(i);
                if (tpos == -1) {
                } else if (code.get(tpos).mappedOffset >= 0) {
                    acode.code.get(i).mappedOffset = code.get(tpos).mappedOffset;
                } else {
                    acode.code.get(i).mappedOffset = pos2adr(tpos);
                }
            }
        }
        this.code = acode.code;
    } catch (IOException ex) {
        Logger.getLogger(AVM2Code.class.getName()).log(Level.SEVERE, null, ex);
    } catch (ParseException ex) {
        Logger.getLogger(AVM2Code.class.getName()).log(Level.FINE, null, ex);
    }
    invalidateCache();
    removeDeadCode(constants, body);
}

Output:
     } catch (ConvertException cex) {
-        cex.printStackTrace();
+        Logger.getLogger(AVM2Code.class.getName()).log(Level.SEVERE, "String_Node_Str", cex);
     }


Input:
protected Object decode(Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
    String sentence = (String) msg;
    if (sentence.contains("String_Node_Str")) {
        if (channel != null) {
            channel.write("String_Node_Str", remoteAddress);
            Parser handshakeParser = new Parser(PATTERN_HANDSHAKE, sentence);
            if (handshakeParser.matches()) {
                identify(handshakeParser.next(), channel);
            }
        }
        return null;
    }
    if (sentence.length() == 15 && Character.isDigit(sentence.charAt(0))) {
        if (channel != null) {
            channel.write("String_Node_Str", remoteAddress);
        }
        return null;
    }
    Parser parser = new Parser(PATTERN, sentence);
    if (!parser.matches()) {
        return null;
    }
    Position position = new Position();
    position.setProtocol(getProtocolName());
    String imei = parser.next();
    if (!identify(imei, channel, remoteAddress)) {
        return null;
    }
    position.setDeviceId(getDeviceId());
    String alarm = parser.next();
    position.set(Event.KEY_ALARM, alarm);
    if (channel != null && alarm.equals("String_Node_Str")) {
        channel.write("String_Node_Str" + imei + "String_Node_Str", remoteAddress);
    }
    DateBuilder dateBuilder = new DateBuilder().setDate(parser.nextInt(), parser.nextInt(), parser.nextInt());
    int localHours = parser.nextInt();
    int localMinutes = parser.nextInt();
    String utcHours = parser.next();
    String utcMinutes = parser.next();
    dateBuilder.setTime(localHours, localMinutes, parser.nextInt(), parser.nextInt());
    if (utcHours != null && utcMinutes != null) {
        int deltaMinutes = (localHours - Integer.valueOf(utcHours)) * 60;
        deltaMinutes += localMinutes - Integer.valueOf(utcMinutes);
        if (deltaMinutes <= -12 * 60) {
            deltaMinutes += 24 * 60;
        } else if (deltaMinutes > 12 * 60) {
            deltaMinutes -= 24 * 60;
        }
        dateBuilder.addMinute(-deltaMinutes);
    }
    position.setTime(dateBuilder.getDate());
    position.setValid(parser.next().equals("String_Node_Str"));
    position.setLatitude(parser.nextCoordinate(Parser.CoordinateFormat.HEM_DEG_MIN_HEM));
    position.setLongitude(parser.nextCoordinate(Parser.CoordinateFormat.HEM_DEG_MIN_HEM));
    position.setSpeed(parser.nextDouble());
    position.setCourse(parser.nextDouble());
    position.setAltitude(parser.nextDouble());
    for (int i = 1; i <= 5; i++) {
        position.set(Event.PREFIX_IO + i, parser.next());
    }
    return position;
}

Output:
     if (utcHours != null && utcMinutes != null) {
-        int deltaMinutes = (localHours - Integer.valueOf(utcHours)) * 60;
-        deltaMinutes += localMinutes - Integer.valueOf(utcMinutes);
+        int deltaMinutes = (localHours - Integer.parseInt(utcHours)) * 60;
+        deltaMinutes += localMinutes - Integer.parseInt(utcMinutes);
         if (deltaMinutes <= -12 * 60) {


Input:
public static void kickLocalArtifactReloadEvent(Object source, Collection<? extends Artifact> artifacts) throws OseeCoreException {
    if (isDisableEvents()) {
        return;
    }
    ArtifactEvent artifactEvent = new ArtifactEvent(artifacts.iterator().next().getBranch(), ArtifactEventType.RELOAD_ARTIFACTS);
    artifactEvent.getArtifacts().addAll(EventBasicGuidArtifact.get(EventModType.Reloaded, artifacts));
    getEventService().send(source, artifactEvent);
}

Output:
     }
-    ArtifactEvent artifactEvent = new ArtifactEvent(artifacts.iterator().next().getBranch(), ArtifactEventType.RELOAD_ARTIFACTS);
+    ArtifactEvent artifactEvent = new ArtifactEvent(artifacts.iterator().next().getBranch().getGuid(), ArtifactEventType.RELOAD_ARTIFACTS);
     artifactEvent.getArtifacts().addAll(EventBasicGuidArtifact.get(EventModType.Reloaded, artifacts));


Input:
public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
    if (_support == null) {
        synchronized (this) {
            if (_support == null)
                _support = new PropertyChangeSupport(this);
        }
    }
    _support.addPropertyChangeListener(l);
}

Output:
 public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
-    if (_support == null) {
-        synchronized (this) {
-            if (_support == null)
-                _support = new PropertyChangeSupport(this);
-        }
-    }
+    if (_support == null)
+        _support = new PropertyChangeSupport(this);
     _support.addPropertyChangeListener(l);


Input:
public static Vector3 ceil(Vector3 o) {
    return new Vector3(Math.ceil(o.getX()), Math.ceil(o.getY()), Math.ceil(o.getZ()));
}

Output:
 public static Vector3 ceil(Vector3 o) {
-    return new Vector3(Math.ceil(o.getX()), Math.ceil(o.getY()), Math.ceil(o.getZ()));
+    return new Vector3(Math.ceil(o.x), Math.ceil(o.y), Math.ceil(o.z));
 }


Input:
public final Cursor queryAggregationSuggestions(SQLiteQueryBuilder qb, String[] projection, long contactId, int maxSuggestions, String filter, ArrayList<AggregationSuggestionParameter> parameters) {
    final SQLiteDatabase db = mDbHelper.getReadableDatabase();
    db.beginTransaction();
    try {
        List<MatchScore> bestMatches = findMatchingContacts(db, contactId, parameters);
        return queryMatchingContacts(qb, db, projection, bestMatches, maxSuggestions, filter);
    } finally {
        db.endTransaction();
    }
}

Output:
         List<MatchScore> bestMatches = findMatchingContacts(db, contactId, parameters);
-        return queryMatchingContacts(qb, db, projection, bestMatches, maxSuggestions, filter);
+        List<MatchScore> bestMatchesWithoutDuplicateContactIds = new ArrayList<>();
+        Set<Long> contactIds = new HashSet<>();
+        for (MatchScore bestMatch : bestMatches) {
+            long cid = bestMatch.getContactId();
+            if (!contactIds.contains(cid)) {
+                bestMatchesWithoutDuplicateContactIds.add(bestMatch);
+                contactIds.add(cid);
+            }
+        }
+        return queryMatchingContacts(qb, db, projection, bestMatchesWithoutDuplicateContactIds, maxSuggestions, filter);
     } finally {


Input:
public void addEventListener(final String eventName, final LeoObject function) {
    switch(eventName.toLowerCase()) {
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(BombDisarmedEvent.class, new BombDisarmedListener() {
                    public void onBombDisarmedEvent(BombDisarmedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(BombExplodedEvent.class, new BombExplodedListener() {
                    public void onBombExplodedEvent(BombExplodedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(BombPlantedEvent.class, new BombPlantedListener() {
                    public void onBombPlanted(BombPlantedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(FlagCapturedEvent.class, new FlagCapturedListener() {
                    public void onFlagCapturedEvent(FlagCapturedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(FlagReturnedEvent.class, new FlagReturnedListener() {
                    public void onFlagReturnedEvent(FlagReturnedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(FlagStolenEvent.class, new FlagStolenListener() {
                    public void onFlagStolenEvent(FlagStolenEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(GameEndEvent.class, new GameEndListener() {
                    public void onGameEnd(GameEndEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(KillRollEvent.class, new KillRollListener() {
                    public void onKillRoll(KillRollEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(KillStreakEvent.class, new KillStreakListener() {
                    public void onKillStreak(KillStreakEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(PlayerAwardEvent.class, new PlayerAwardListener() {
                    public void onPlayerAward(PlayerAwardEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(PlayerJoinedEvent.class, new PlayerJoinedListener() {
                    public void onPlayerJoined(PlayerJoinedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(PlayerKilledEvent.class, new PlayerKilledListener() {
                    public void onPlayerKilled(PlayerKilledEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(PlayerLeftEvent.class, new PlayerLeftListener() {
                    public void onPlayerLeft(PlayerLeftEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(PlayerSpawnedEvent.class, new PlayerSpawnedListener() {
                    public void onPlayerSpawned(PlayerSpawnedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(RoundEndedEvent.class, new RoundEndedListener() {
                    public void onRoundEnded(RoundEndedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(RoundStartedEvent.class, new RoundStartedListener() {

                    public void onRoundStarted(RoundStartedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(SoundEmittedEvent.class, new SoundEmitterListener() {
                    public void onSoundEmitted(SoundEmittedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(SurvivorEvent.class, new SurvivorEventListener() {
                    public void onSurvivorEvent(SurvivorEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        case "String_Node_Str":
            {
                this.dispatcher.addEventListener(TileRemovedEvent.class, new TileRemovedListener() {
                    public void onTileRemoved(TileRemovedEvent event) {
                        callFunction(eventName, function, event);
                    }
                });
                break;
            }
        default:
            {
                Cons.println("String_Node_Str" + eventName + "String_Node_Str");
            }
    }
}

Output:
             {
-                this.dispatcher.addEventListener(RoundStartedEvent.class, new RoundStartedListener() {
+                addEventListener(RoundStartedEvent.class, new RoundStartedListener() {


Input:
public void generate(Random random, int chunkX, int chunkZ, World world, net.minecraft.world.gen.IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    final int x = chunkX * 16 + 8;
    final int z = chunkZ * 16 + 8;
    final Biome biome = world.getBiomeForCoordsBody(new BlockPos(x, 0, z));
    if (BiomeDictionary.hasType(biome, BiomeDictionary.Type.DEAD)) {
        return;
    }
    if (config.enablearidgardenGeneration && (BiomeDictionary.hasType(biome, BiomeDictionary.Type.SANDY)) || (BiomeDictionary.hasType(biome, BiomeDictionary.Type.MESA))) {
        generateGarden(BlockRegistry.getGarden(BlockRegistry.aridGarden), world, random, x, z);
    }
    if (config.enablefrostgardenGeneration && (BiomeDictionary.hasType(biome, BiomeDictionary.Type.SNOWY)) || (BiomeDictionary.hasType(biome, BiomeDictionary.Type.MOUNTAIN))) {
        generateGarden(BlockRegistry.getGarden(BlockRegistry.frostGarden), world, random, x, z);
    }
    if (config.enableshadedgardenGeneration && (BiomeDictionary.hasType(biome, BiomeDictionary.Type.FOREST)) || (BiomeDictionary.hasType(biome, BiomeDictionary.Type.SPOOKY))) {
        generateGarden(BlockRegistry.getGarden(BlockRegistry.shadedGarden), world, random, x, z);
    }
    if (config.enablesoggygardenGeneration && (BiomeDictionary.hasType(biome, BiomeDictionary.Type.SWAMP)) || (BiomeDictionary.hasType(biome, BiomeDictionary.Type.RIVER))) {
        generateGarden(BlockRegistry.getGarden(BlockRegistry.soggyGarden), world, random, x, z);
    }
    if (config.enabletropicalgardenGeneration && (BiomeDictionary.hasType(biome, BiomeDictionary.Type.JUNGLE)) || (BiomeDictionary.hasType(biome, BiomeDictionary.Type.OCEAN))) {
        generateGarden(BlockRegistry.getGarden(BlockRegistry.tropicalGarden), world, random, x, z);
    }
    if (config.enablewindygardenGeneration && (BiomeDictionary.hasType(biome, BiomeDictionary.Type.PLAINS)) || (BiomeDictionary.hasType(biome, BiomeDictionary.Type.SAVANNA))) {
        generateGarden(BlockRegistry.getGarden(BlockRegistry.windyGarden), world, random, x, z);
    }
}

Output:
     }
-    if (config.enablearidgardenGeneration && (BiomeDictionary.hasType(biome, BiomeDictionary.Type.SANDY)) || (BiomeDictionary.hasType(biome, BiomeDictionary.Type.MESA))) {
+    if (config.enablearidgardenGeneration && (BiomeDictionary.hasType(biome, BiomeDictionary.Type.SANDY) || BiomeDictionary.hasType(biome, BiomeDictionary.Type.MESA))) {
         generateGarden(BlockRegistry.getGarden(BlockRegistry.aridGarden), world, random, x, z);


Input:
private void triggerSelectionBlock() {
    int iCount = iFirstSample;
    for (int i = 0; i < iSelectorBar - 1; i++) iCount += iAlNumberSamples.get(i);
    List<SelectionCommand> commands = new ArrayList<SelectionCommand>();
    SelectionCommand command = new SelectionCommand(ESelectionCommandType.RESET);
    commands.add(command);
    glHeatMapView.handleContentTriggerSelectionCommand(eFieldDataType, commands);
    IVirtualArrayDelta delta = new VirtualArrayDelta(eFieldDataType);
    ISelectionDelta selectionDelta = new SelectionDelta(eFieldDataType);
    IVirtualArray currentVirtualArray = set.getVA(iContentVAID);
    int iIndex = 0;
    int iContentIndex = 0;
    for (int index = 0; index < iSamplesPerHeatmap; index++) {
        iIndex = iCount + index;
        if (iIndex < currentVirtualArray.size()) {
            iContentIndex = currentVirtualArray.get(iIndex);
        }
        delta.add(VADeltaItem.append(iContentIndex));
        for (HeatMapSelection selection : AlSelection) {
            if (selection.getContentIndex() == iContentIndex) {
                selectionDelta.addSelection(iContentIndex, selection.getSelectionType());
            }
        }
    }
    glHeatMapView.handleVirtualArrayUpdate(delta, getShortInfo());
    if (selectionDelta.size() > 0) {
        glHeatMapView.handleSelectionUpdate(selectionDelta, true, null);
    }
    commands = new ArrayList<SelectionCommand>();
    command = new SelectionCommand(ESelectionCommandType.RESET);
    commands.add(command);
    glHeatMapView.handleStorageTriggerSelectionCommand(eExperimentDataType, commands);
    IVirtualArrayDelta deltaExp = new VirtualArrayDelta(eExperimentDataType);
    ISelectionDelta selectionDeltaEx = new SelectionDelta(eExperimentDataType);
    IVirtualArray currentVirtualArrayEx = set.getVA(iStorageVAID);
    for (int index = 0; index < currentVirtualArrayEx.size(); index++) {
        iContentIndex = currentVirtualArrayEx.get(index);
        deltaExp.add(VADeltaItem.append(iContentIndex));
        for (Integer selection : AlExpMouseOver) {
            if (selection == iContentIndex) {
                selectionDeltaEx.addSelection(iContentIndex, ESelectionType.MOUSE_OVER);
            }
        }
        for (Integer selection : AlExpSelected) {
            if (selection == iContentIndex) {
                selectionDeltaEx.addSelection(iContentIndex, ESelectionType.SELECTION);
            }
        }
    }
    glHeatMapView.handleVirtualArrayUpdate(deltaExp, getShortInfo());
    if (selectionDeltaEx.size() > 0) {
        glHeatMapView.handleSelectionUpdate(selectionDeltaEx, true, null);
    }
}

Output:
     commands = new ArrayList<SelectionCommand>();
-    command = new SelectionCommand(ESelectionCommandType.RESET);
+    SelectionCommand command = new SelectionCommand(ESelectionCommandType.RESET);
     commands.add(command);


Input:
public static Program create(CConfiguration cConf, ProgramRunner programRunner, Location programJarLocation, File unpackedDir) throws IOException {
    FilterClassLoader.Filter filter;
    if (programRunner instanceof ProgramClassLoaderFilterProvider) {
        filter = ((ProgramClassLoaderFilterProvider) programRunner).getFilter();
    } else {
        filter = FilterClassLoader.defaultFilter();
    }
    if (filter == null) {
        throw new IOException("String_Node_Str");
    }
    FilterClassLoader parentClassLoader = new FilterClassLoader(programRunner.getClass().getClassLoader(), filter);
    final ProgramClassLoader programClassLoader = new ProgramClassLoader(cConf, unpackedDir, parentClassLoader);
    return new ForwardingProgram(Programs.create(programJarLocation, programClassLoader)) {
        public void close() throws IOException {
            Closeables.closeQuietly(programClassLoader);
            super.close();
        }
    };
}

Output:
 public static Program create(CConfiguration cConf, ProgramRunner programRunner, Location programJarLocation, File unpackedDir) throws IOException {
-    FilterClassLoader.Filter filter;
-    if (programRunner instanceof ProgramClassLoaderFilterProvider) {
-        filter = ((ProgramClassLoaderFilterProvider) programRunner).getFilter();
+    final ProgramClassLoader programClassLoader;
+    if (programRunner instanceof ProgramClassLoaderProvider) {
+        programClassLoader = ((ProgramClassLoaderProvider) programRunner).createProgramClassLoader(cConf, unpackedDir);
     } else {


Input:
private void clickImpl(Object graphicsComponent, ClickOptions clickOptions) {
    int buttonMask = getButtonMask(clickOptions.getMouseButton());
    int clickCount = clickOptions.getClickCount();
    int[] modifierMask = getModifierMask(clickOptions.getClickModifier());
    if (clickCount > 0) {
        final InterceptorOptions options = new InterceptorOptions(new long[] { SWT.MouseUp, SWT.MouseDown });
        final IEventMatcher matcher = new ClickSwtEventMatcher(clickOptions);
        final IRobotEventConfirmer confirmer = m_interceptor.intercept(options);
        try {
            pressModifier(modifierMask);
            RobotTiming.sleepPreClickDelay();
            for (int i = 0; i < clickCount; i++) {
                m_robot.mousePress(buttonMask);
                RobotTiming.sleepPostMouseDownDelay();
                m_robot.mouseRelease(buttonMask);
                RobotTiming.sleepPostMouseUpDelay();
            }
            if (clickOptions.isConfirmClick()) {
                try {
                    confirmer.waitToConfirm(graphicsComponent, matcher);
                } catch (RobotException re) {
                    StringBuffer sb = new StringBuffer("String_Node_Str");
                    logRobotException(graphicsComponent, re, sb);
                    throw re;
                }
            }
        } finally {
            releaseModifier(modifierMask);
        }
    }
}

Output:
         final IEventMatcher matcher = new ClickSwtEventMatcher(clickOptions);
-        final IRobotEventConfirmer confirmer = m_interceptor.intercept(options);
+        IRobotEventConfirmer confirmer = null;
+        if (clickOptions.isConfirmClick()) {
+            final InterceptorOptions options = new InterceptorOptions(new long[] { SWT.MouseUp, SWT.MouseDown });
+            confirmer = m_interceptor.intercept(options);
+        }
         try {


Input:
public void run() throws Exception {
    InternalPartitionServiceImpl partitionService = getService();
    int partitionId = getPartitionId();
    int replicaIndex = getReplicaIndex();
    long[] currentVersions = partitionService.getPartitionReplicaVersions(partitionId);
    long currentVersion = currentVersions[replicaIndex - 1];
    if (currentVersion == version) {
        response = true;
    } else {
        logBackupVersionMismatch(currentVersion);
        partitionService.syncPartitionReplica(partitionId, replicaIndex, false);
        response = false;
    }
}

Output:
         logBackupVersionMismatch(currentVersion);
-        partitionService.syncPartitionReplica(partitionId, replicaIndex, false);
+        partitionService.triggerPartitionReplicaSync(partitionId, replicaIndex);
         response = false;


Input:
protected IStatus run(IProgressMonitor monitor) {
    try {
        XWikiEclipsePageIndex pageIndex = XWikiEclipsePageIndex.getDefault();
        monitor.beginTask(String.format("String_Node_Str"), IProgressMonitor.UNKNOWN);
        if (monitor.isCanceled()) {
            return Status.CANCEL_STATUS;
        }
        Collection<IXWikiSpace> spaces = connection.getSpaces();
        for (IXWikiSpace space : spaces) {
            if (monitor.isCanceled()) {
                return Status.CANCEL_STATUS;
            }
            Collection<IXWikiPage> pages = space.getPages();
            for (IXWikiPage page : pages) {
                pageIndex.addPage(page);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        return new Status(IStatus.ERROR, XWikiEclipsePlugin.PLUGIN_ID, String.format("String_Node_Str", e.getMessage()));
    } finally {
        monitor.done();
        if (reschedule) {
            schedule(1200000);
        }
    }
    return Status.OK_STATUS;
}

Output:
         monitor.beginTask(String.format("String_Node_Str"), IProgressMonitor.UNKNOWN);
-        if (monitor.isCanceled()) {
+        if (monitor.isCanceled() || !connection.isConnected()) {
             return Status.CANCEL_STATUS;


Input:
public boolean isSaveable() {
    return true;
}

Output:
 public boolean isSaveable() {
-    return true;
+    return !external;
 }


Input:
public void setActivePage(IEditorPart thePart) {
    if (Util.isTraceEnabled(this)) {
        Util.printEntered(this, new StringBuffer().append("String_Node_Str").append(thePart).append("String_Node_Str").append(activeEditor).toString());
    }
    AbstractModelEditorPageActionBarContributor contributor = null;
    IEditorPart part = thePart;
    if (thePart instanceof ModelEditor) {
        part = ((ModelEditor) thePart).getCurrentPage();
    }
    if (this.partContributorMap != null) {
        Iterator itrContributor = this.partContributorMap.values().iterator();
        while (itrContributor.hasNext()) {
            IEditorActionBarContributor pageContributor = (IEditorActionBarContributor) itrContributor.next();
            if (pageContributor != null) {
                pageContributor.setActiveEditor(part);
            }
        }
    }
    contributor = getActionContributor(part);
    if (contributor != null) {
        contributor.setActiveEditor(part);
    }
    ModelerGlobalActionsMap globalActions = (contributor == null) ? (ModelerGlobalActionsMap) defaultActionsMap : (ModelerGlobalActionsMap) contributor.getGlobalActions();
    if (globalActions == null) {
        globalActions = new ModelerGlobalActionsMap();
    }
    IWorkbenchWindow window = getPage().getWorkbenchWindow();
    ActionService actionService = (contributor == null) ? UiPlugin.getDefault().getActionService(window.getActivePage()) : contributor.getActionService();
    Iterator itr = globalActions.entrySet().iterator();
    while (itr.hasNext()) {
        Map.Entry entry = (Map.Entry) itr.next();
        String actionId = (String) entry.getKey();
        IAction action = (globalActions.isDefaultAction(actionId)) ? actionService.getDefaultAction(actionId) : (IAction) entry.getValue();
        if (action == null) {
            action = GlobalActionsMap.UNSUPPORTED_ACTION;
        }
        getActionBars().setGlobalActionHandler(actionId, action);
        IHandlerService svc = (IHandlerService) part.getSite().getService(IHandlerService.class);
        svc.activateHandler(actionId, new ActionHandler(action));
    }
    getActionBars().updateActionBars();
    activeEditor = part;
    if (Util.isTraceEnabled(this)) {
        Util.printExited(this, "String_Node_Str");
    }
}

Output:
         getActionBars().setGlobalActionHandler(actionId, action);
-        IHandlerService svc = (IHandlerService) part.getSite().getService(IHandlerService.class);
-        svc.activateHandler(actionId, new ActionHandler(action));
+        if (this.actionHandlerMap.containsKey(actionId)) {
+            svc.deactivateHandler(this.actionHandlerMap.get(actionId));
+        }
+        this.actionHandlerMap.put(actionId, svc.activateHandler(actionId, new ActionHandler(action)));
     }


Input:
private void handleResponseToSelfHostedSettingsSetRequest(Map result) {
    AppLog.d(AppLog.T.API, "String_Node_Str");
    mBlog.setBlogName(getNestedMapValue(result, "String_Node_Str"));
    WordPress.wpDB.saveBlog(mBlog);
    EventBus.getDefault().post(new CoreEvents.BlogListChanged());
}

Output:
     AppLog.d(AppLog.T.API, "String_Node_Str");
-    mBlog.setBlogName(getNestedMapValue(result, "String_Node_Str"));
+    mBlog.setBlogName(StringUtils.unescapeHTML(getNestedMapValue(result, "String_Node_Str")));
     WordPress.wpDB.saveBlog(mBlog);


Input:
public boolean isInUseableZone(Game game, MageObject source, GameEvent event) {
    if (event != null && event.getTargetId() != null && event.getTargetId().equals(getSourceId())) {
        switch(event.getType()) {
            case ZONE_CHANGE:
            case DESTROYED_PERMANENT:
                if (event.getType().equals(EventType.DESTROYED_PERMANENT)) {
                    source = game.getLastKnownInformation(getSourceId(), Zone.BATTLEFIELD);
                } else {
                    if (((ZoneChangeEvent) event).getTarget() != null) {
                        source = ((ZoneChangeEvent) event).getTarget();
                    } else {
                        source = game.getLastKnownInformation(getSourceId(), ((ZoneChangeEvent) event).getZone());
                    }
                }
            case PHASED_OUT:
            case PHASED_IN:
                if (this.zone == Zone.ALL || game.getLastKnownInformation(getSourceId(), zone) != null) {
                    return this.hasSourceObjectAbility(game, source, event);
                }
        }
    }
    return super.isInUseableZone(game, source, event);
}

Output:
             case DESTROYED_PERMANENT:
-                if (event.getType().equals(EventType.DESTROYED_PERMANENT)) {
-                    source = game.getLastKnownInformation(getSourceId(), Zone.BATTLEFIELD);
-                } else {
-                    if (((ZoneChangeEvent) event).getTarget() != null) {
-                        source = ((ZoneChangeEvent) event).getTarget();
+                if (isLeavesTheBattlefieldTrigger()) {
+                    if (event.getType().equals(EventType.DESTROYED_PERMANENT)) {
+                        source = game.getLastKnownInformation(getSourceId(), Zone.BATTLEFIELD);
                     } else {


Input:
public List<String> getAllCandidates(CommandContext ctx) {
    ModelControllerClient client = ctx.getModelControllerClient();
    if (client == null) {
        return Collections.emptyList();
    }
    final String profileArg;
    if (!ctx.isDomainMode()) {
        profileArg = null;
    } else {
        profileArg = profile.getValue(ctx.getParsedArguments());
        if (profileArg == null) {
            return Collections.emptyList();
        }
    }
    return Util.getDatasources(ctx.getModelControllerClient(), profileArg, dsType);
}

Output:
 public List<String> getAllCandidates(CommandContext ctx) {
-    ModelControllerClient client = ctx.getModelControllerClient();
+    NewModelControllerClient client = ctx.getModelControllerClient();
     if (client == null) {


Input:
public void watch(GameEvent event, Game game) {
    if (event.getType() == GameEvent.EventType.MANA_PAYED) {
        if (event.getSourceId().equals(this.sourceId)) {
            spells.add(event.getTargetId());
        }
    }
}

Output:
     if (event.getType() == GameEvent.EventType.MANA_PAYED) {
-        if (event.getSourceId().equals(this.sourceId)) {
+        if (game.getObject(event.getSourceId()).getName().equals("String_Node_Str")) {
             spells.add(event.getTargetId());


Input:
public MetricValue find(K key) {
    SliceQuery<String, String, Object> query = HFactory.createSliceQuery(keySpace, StringSerializer.get(), StringSerializer.get(), ObjectSerializer.get());
    QueryResult<ColumnSlice<String, Object>> result = query.setColumnFamily(columnFamilyName).setKey((String) key).setRange("String_Node_Str", "String_Node_Str", false, 10).execute();
    try {
        if (result.get().getColumns().isEmpty()) {
            return null;
        }
    } catch (Exception e) {
        return null;
    }
    try {
        MetricValue metricValue = new MetricValue<K>(key);
        Map<String, Object> columns = metricValue.getColumns();
        ColumnSlice<String, Object> queryResult = result.get();
        for (HColumn<String, Object> column : queryResult.getColumns()) {
            Object val = column.getValue();
            columns.put(column.getName(), val);
        }
        return metricValue;
    } catch (Exception e) {
        throw new RuntimeException("String_Node_Str", e);
    }
}

Output:
     } catch (Exception e) {
-        throw new RuntimeException("String_Node_Str", e);
+        throw new RuntimeException("String_Node_Str" + key, e);
     }


Input:
public void checkRefsBOInMatchingState(BusinessObjectRef boRef) {
    EObject owner = objLookup.getVersionedOwner(boRef);
    ILifecycleStateResolver stateRes = new StateAttributeLifecycleStateResolver(owner.eResource().getResourceSet());
    if (owner != null && stateRes.definesState(owner)) {
        if (!referencedStateChecker.stateMatches(((BusinessObject) boRef.getType()).getState(), owner))
            error("String_Node_Str", ServiceDslPackage.Literals.BUSINESS_OBJECT_REF__TYPE);
    }
}

Output:
 public void checkRefsBOInMatchingState(BusinessObjectRef boRef) {
-    EObject owner = objLookup.getVersionedOwner(boRef);
+    EObject owner = objLookup.getStatefulOwner(boRef);
     ILifecycleStateResolver stateRes = new StateAttributeLifecycleStateResolver(owner.eResource().getResourceSet());


Input:
public Entity getVehicle() {
    return getHandle().getRiding().isPresent() ? PoreEntity.of(getHandle().getRiding().get()) : null;
}

Output:
 public Entity getVehicle() {
-    return getHandle().getRiding().isPresent() ? PoreEntity.of(getHandle().getRiding().get()) : null;
+    return getHandle().getVehicle().isPresent() ? PoreEntity.of(getHandle().getVehicle().get()) : null;
 }


Input:
private void streamPropertyChange(PropertyChangeEvent ev) {
    String propertyName = ev.getPropertyName();
    String prefix = MediaStreamImpl.class.getName() + "String_Node_Str";
    if (propertyName.startsWith(prefix)) {
        Object newValue = ev.getNewValue();
        if (newValue instanceof RTPConnectorInputStream) {
            String rtpConnectorPropertyName = propertyName.substring(0, prefix.length());
            DatagramPacketFilter datagramPacketFilter;
            if (rtpConnectorPropertyName.equals("String_Node_Str")) {
                datagramPacketFilter = new DatagramPacketFilter() {
                    public boolean accept(DatagramPacket p) {
                        return acceptControlInputStreamDatagramPacket(p);
                    }
                };
            } else if (rtpConnectorPropertyName.equals("String_Node_Str")) {
                datagramPacketFilter = new DatagramPacketFilter() {
                    public boolean accept(DatagramPacket p) {
                        return acceptDataInputStreamDatagramPacket(p);
                    }
                };
            } else
                datagramPacketFilter = null;
            if (datagramPacketFilter != null) {
                ((RTPConnectorInputStream) newValue).addDatagramPacketFilter(datagramPacketFilter);
            }
        }
    }
}

Output:
         if (newValue instanceof RTPConnectorInputStream) {
-            String rtpConnectorPropertyName = propertyName.substring(0, prefix.length());
+            String rtpConnectorPropertyName = propertyName.substring(prefix.length());
             DatagramPacketFilter datagramPacketFilter;


Input:
public void basicTest() throws Exception {
    String htmlSource = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    HTMLDocumentImpl doc = loadPage(htmlSource);
    assertTrue(BODY.equals(doc.getElementById("String_Node_Str").getNodeName()));
}

Output:
 public void basicTest() throws Exception {
-    String htmlSource = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
+    String htmlSource = "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
     HTMLDocumentImpl doc = loadPage(htmlSource);


Input:
public BoundedSet<V> join(BoundedSet<V> other) {
    if (this.isSaturated())
        return this;
    else if (other.isSaturated())
        return other;
    HashSet<V> joinedSet = new HashSet<V>();
    joinedSet.addAll(this.getSet());
    if (other != null)
        joinedSet.addAll(other.getSet());
    BoundedSetImpl r = new BoundedSetImpl(joinedSet);
    System.out.println(String.format("String_Node_Str", this, other, r));
    return r;
}

Output:
         return this;
-    else if (other.isSaturated())
+    else if (other != null && other.isSaturated())
         return other;


Input:
public ArrayList<Property> getPropertyPropertiesForClass(JavaClass cls, TypeInfo info, boolean onlyPublic) {
    ArrayList<Property> properties = new ArrayList<Property>();
    if (cls == null) {
        return properties;
    }
    ArrayList<JavaMethod> getMethods = new ArrayList<JavaMethod>();
    for (JavaMethod next : new ArrayList<JavaMethod>(cls.getDeclaredMethods())) {
        if ((next.getName().startsWith("String_Node_Str") && next.getName().length() > 3) || (next.getName().startsWith("String_Node_Str") && next.getName().length() > 2)) {
            int modifiers = next.getModifiers();
            if (!Modifier.isStatic(modifiers) && !Modifier.isTransient(modifiers) && ((onlyPublic && Modifier.isPublic(next.getModifiers())) || !onlyPublic)) {
                getMethods.add(next);
            }
        }
    }
    boolean hasAnyAttribteProperty = false;
    for (int i = 0; i < getMethods.size(); i++) {
        JavaMethod getMethod = getMethods.get(i);
        String propertyName = "String_Node_Str";
        if (getMethod.getName().startsWith("String_Node_Str")) {
            propertyName = getMethod.getName().substring(3);
        } else if (getMethod.getName().startsWith("String_Node_Str")) {
            propertyName = getMethod.getName().substring(2);
        }
        String setMethodName = "String_Node_Str" + propertyName;
        propertyName = Character.toLowerCase(propertyName.charAt(0)) + propertyName.substring(1);
        JavaClass[] paramTypes = { (JavaClass) getMethod.getReturnType() };
        JavaMethod setMethod = cls.getDeclaredMethod(setMethodName, paramTypes);
        JavaMethod propertyMethod = null;
        if (setMethod != null && !setMethod.getAnnotations().isEmpty()) {
            if (!helper.isAnnotationPresent(setMethod, XmlTransient.class)) {
                propertyMethod = setMethod;
            }
        } else {
            if (!helper.isAnnotationPresent(getMethod, XmlTransient.class)) {
                propertyMethod = getMethod;
            }
        }
        Property property = null;
        if (helper.isAnnotationPresent(propertyMethod, XmlElements.class)) {
            property = new ChoiceProperty(helper);
        } else if (helper.isAnnotationPresent(propertyMethod, XmlAnyElement.class)) {
            property = new AnyProperty(helper);
        } else if (helper.isAnnotationPresent(propertyMethod, XmlElementRef.class) || helper.isAnnotationPresent(propertyMethod, XmlElementRefs.class)) {
            property = new ReferenceProperty(helper);
        } else {
            property = new Property(helper);
        }
        if (helper.isAnnotationPresent(propertyMethod, XmlMixed.class)) {
            info.setMixed(true);
        }
        property.setElement(propertyMethod);
        property.setSchemaName(getQNameForProperty(propertyName, propertyMethod, getNamespaceInfoForPackage(cls.getPackage())));
        property.setPropertyName(propertyName);
        JavaClass returnClass = (JavaClass) getMethod.getReturnType();
        if (!helper.isAnnotationPresent(returnClass, XmlTransient.class)) {
            property.setType(returnClass);
        } else {
            JavaClass parent = returnClass.getSuperclass();
            while (parent != null) {
                if (parent.getName().equals("String_Node_Str")) {
                    property.setType(parent);
                    break;
                }
                if (!helper.isAnnotationPresent(parent, XmlTransient.class)) {
                    property.setType(parent);
                    break;
                }
                parent = parent.getSuperclass();
            }
        }
        property.setGenericType(helper.getGenericReturnType(getMethod));
        property.setGetMethodName(getMethod.getName());
        property.setSetMethodName(setMethodName);
        property.setMethodProperty(true);
        JavaClass ptype = property.getType();
        if (helper.isAnnotationPresent(property.getElement(), XmlJavaTypeAdapter.class)) {
            XmlJavaTypeAdapter adapter = (XmlJavaTypeAdapter) helper.getAnnotation(property.getElement(), XmlJavaTypeAdapter.class);
            property.setAdapterClass(adapter.value());
        } else if (info.getAdaptersByClass().get(ptype) != null) {
            property.setAdapterClass(info.getAdaptersByClass().get(ptype));
        }
        if (property.hasAdapterClass()) {
            ptype = property.getValueType();
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlSchemaType.class)) {
            XmlSchemaType schemaType = (XmlSchemaType) helper.getAnnotation(property.getElement(), XmlSchemaType.class);
            QName schemaTypeQname = new QName(schemaType.namespace(), schemaType.name());
            property.setSchemaType(schemaTypeQname);
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlAttachmentRef.class) && areEquals(ptype, JAVAX_ACTIVATION_DATAHANDLER)) {
            property.setIsSwaAttachmentRef(true);
            property.setSchemaType(XMLConstants.SWA_REF_QNAME);
        } else if (areEquals(ptype, JAVAX_ACTIVATION_DATAHANDLER) || areEquals(ptype, byte[].class) || areEquals(ptype, Byte[].class) || areEquals(ptype, Image.class) || areEquals(ptype, Source.class) || areEquals(ptype, JAVAX_MAIL_INTERNET_MIMEMULTIPART)) {
            property.setIsMtomAttachment(true);
            property.setSchemaType(XMLConstants.BASE_64_BINARY_QNAME);
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlMimeType.class)) {
            property.setMimeType(((XmlMimeType) helper.getAnnotation(property.getElement(), XmlMimeType.class)).value());
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlJavaTypeAdapter.class)) {
            XmlJavaTypeAdapter adapter = (XmlJavaTypeAdapter) helper.getAnnotation(property.getElement(), XmlJavaTypeAdapter.class);
            property.setAdapterClass(adapter.value());
        } else if (info.getAdaptersByClass().get(ptype) != null) {
            property.setAdapterClass(info.getAdaptersByClass().get(ptype));
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlAttribute.class)) {
            property.setIsAttribute(true);
            property.setIsRequired(((XmlAttribute) helper.getAnnotation(property.getElement(), XmlAttribute.class)).required());
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlAnyAttribute.class)) {
            if (hasAnyAttribteProperty) {
                throw org.eclipse.persistence.exceptions.JAXBException.multipleAnyAttributeMapping(cls.getName());
            }
            if (!ptype.getName().equals("String_Node_Str")) {
                throw org.eclipse.persistence.exceptions.JAXBException.anyAttributeOnNonMap(property.getPropertyName());
            }
            property.setIsAttribute(true);
            hasAnyAttribteProperty = true;
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlElements.class)) {
            XmlElements xmlElements = (XmlElements) helper.getAnnotation(property.getElement(), XmlElements.class);
            XmlElement[] elements = xmlElements.value();
            ArrayList<Property> choiceProperties = new ArrayList<Property>(elements.length);
            for (int j = 0; j < elements.length; j++) {
                XmlElement next = elements[j];
                Property choiceProp = new Property();
                String name = next.name();
                String namespace = next.namespace();
                QName qName = null;
                if (name.equals("String_Node_Str")) {
                    name = propertyName;
                }
                if (!namespace.equals("String_Node_Str")) {
                    qName = new QName(namespace, name);
                } else {
                    qName = new QName(name);
                }
                choiceProp.setPropertyName(property.getPropertyName());
                choiceProp.setType(helper.getJavaClass(next.type()));
                choiceProp.setSchemaName(qName);
                choiceProp.setSchemaType(getSchemaTypeFor(helper.getJavaClass(next.type())));
                choiceProp.setElement(property.getElement());
                choiceProperties.add(choiceProp);
            }
            ((ChoiceProperty) property).setChoiceProperties(choiceProperties);
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlAnyElement.class)) {
            XmlAnyElement anyElement = (XmlAnyElement) helper.getAnnotation(property.getElement(), XmlAnyElement.class);
            ((AnyProperty) property).setDomHandlerClass(anyElement.value());
            ((AnyProperty) property).setLax(anyElement.lax());
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlElementRef.class) || helper.isAnnotationPresent(property.getElement(), XmlElementRefs.class)) {
            XmlElementRef[] elementRefs;
            XmlElementRef ref = (XmlElementRef) helper.getAnnotation(property.getElement(), XmlElementRef.class);
            if (ref != null) {
                elementRefs = new XmlElementRef[] { ref };
            } else {
                XmlElementRefs refs = (XmlElementRefs) helper.getAnnotation(property.getElement(), XmlElementRefs.class);
                elementRefs = refs.value();
                info.setHasElementRefs(true);
            }
            for (XmlElementRef nextRef : elementRefs) {
                JavaClass type = ptype;
                String typeName = type.getQualifiedName();
                property.setType(type);
                if (isCollectionType(property)) {
                    if (type.hasActualTypeArguments()) {
                        type = (JavaClass) type.getActualTypeArguments().toArray()[0];
                        typeName = type.getQualifiedName();
                    }
                }
                if (nextRef.type() != XmlElementRef.DEFAULT.class) {
                    typeName = helper.getJavaClass(nextRef.type()).getQualifiedName();
                }
                ElementDeclaration referencedElement = this.xmlRootElements.get(typeName);
                if (referencedElement != null) {
                    addReferencedElement((ReferenceProperty) property, referencedElement);
                } else {
                    String name = nextRef.name();
                    String namespace = nextRef.namespace();
                    if (namespace.equals("String_Node_Str")) {
                        namespace = "String_Node_Str";
                    }
                    QName qname = new QName(namespace, name);
                    referencedElement = this.globalElements.get(qname);
                    if (referencedElement != null) {
                        addReferencedElement((ReferenceProperty) property, referencedElement);
                    } else {
                        throw org.eclipse.persistence.exceptions.JAXBException.invalidElementRef(property.getPropertyName(), cls.getName());
                    }
                }
            }
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlValue.class)) {
            info.setXmlValueProperty(property);
            JavaClass parent = cls.getSuperclass();
            while (parent != null && !(parent.getQualifiedName().equals("String_Node_Str"))) {
                if (typeInfo.get(parent.getQualifiedName()) != null) {
                    throw JAXBException.propertyOrFieldCannotBeXmlValue(propertyName);
                }
                parent = parent.getSuperclass();
            }
        }
        if (!helper.isAnnotationPresent(property.getElement(), XmlTransient.class)) {
            properties.add(property);
        } else {
            List<String> propOrderList = Arrays.asList(info.getPropOrder());
            if (propOrderList.contains(propertyName)) {
                throw JAXBException.transientInProporder(propertyName);
            }
        }
        if (ptype.isPrimitive()) {
            property.setIsRequired(true);
        } else if (helper.isAnnotationPresent(property.getElement(), XmlElement.class)) {
            property.setIsRequired(((XmlElement) helper.getAnnotation(property.getElement(), XmlElement.class)).required());
        }
    }
    return properties;
}

Output:
         property.setGetMethodName(getMethod.getName());
-        property.setSetMethodName(setMethodName);
+        if (setMethod != null) {
+            property.setSetMethodName(setMethodName);
+        }
         property.setMethodProperty(true);


Input:
static VanillaSharedReplicatedHashMap<Integer, CharSequence> newSocketShmIntString(final byte identifier, final int serverPort, ClientPort... clientSocketChannelProviderMaps) throws IOException {
    final VanillaSharedReplicatedHashMapBuilder builder = new VanillaSharedReplicatedHashMapBuilder().entries(1000).identifier(identifier);
    final VanillaSharedReplicatedHashMap<Integer, CharSequence> result = builder.create(getPersistenceFile(), Integer.class, CharSequence.class);
    final int adjustedEntrySize = result.maxEntrySize();
    final short maxNumberOfEntriesPerChunk = ServerTcpSocketReplicator.toMaxNumberOfEntriesPerChunk(1024 * 8, adjustedEntrySize);
    for (ClientPort clientSocketChannelProvider : clientSocketChannelProviderMaps) {
        final SocketChannelEntryWriter socketChannelEntryWriter0 = new SocketChannelEntryWriter(adjustedEntrySize, maxNumberOfEntriesPerChunk, result);
        final SocketChannelEntryReader socketChannelEntryReader = new SocketChannelEntryReader(adjustedEntrySize, result);
        ClientTcpSocketReplicator clientTcpSocketReplicator = new ClientTcpSocketReplicator(clientSocketChannelProvider, socketChannelEntryReader, socketChannelEntryWriter0, result);
        result.addCloseable(clientTcpSocketReplicator);
    }
    final SocketChannelEntryWriter socketChannelEntryWriter = new SocketChannelEntryWriter(adjustedEntrySize, maxNumberOfEntriesPerChunk, result);
    final ServerTcpSocketReplicator serverTcpSocketReplicator = new ServerTcpSocketReplicator(result, result, serverPort, socketChannelEntryWriter);
    result.addCloseable(serverTcpSocketReplicator);
    return result;
}

Output:
     final VanillaSharedReplicatedHashMap<Integer, CharSequence> result = builder.create(getPersistenceFile(), Integer.class, CharSequence.class);
-    final int adjustedEntrySize = result.maxEntrySize();
+    final int adjustedEntrySize = result.maxEntrySize() + 128;
     final short maxNumberOfEntriesPerChunk = ServerTcpSocketReplicator.toMaxNumberOfEntriesPerChunk(1024 * 8, adjustedEntrySize);


Input:
private Object[] executePartitionAwareOperations(PartitionAwareOperationFactory partitionAwareFactory) {
    partitionAwareFactory.init(getNodeEngine());
    NodeEngine nodeEngine = getNodeEngine();
    int[] operationFactoryPartitions = partitionAwareFactory.getPartitions();
    partitions = operationFactoryPartitions == null ? partitions : operationFactoryPartitions;
    Object[] responses = new Object[partitions.length];
    for (int i = 0; i < partitions.length; i++) {
        ResponseQueue responseQueue = new ResponseQueue();
        responses[i] = responseQueue;
        int partition = partitions[i];
        Operation operation = partitionAwareFactory.createPartitionOperation(partition);
        operation.setNodeEngine(nodeEngine).setPartitionId(partition).setReplicaIndex(getReplicaIndex()).setOperationResponseHandler(responseQueue).setServiceName(getServiceName()).setService(getService()).setCallerUuid(extractCallerUuid());
        OperationAccessor.setCallerAddress(operation, getCallerAddress());
        nodeEngine.getOperationService().execute(operation);
    }
    return responses;
}

Output:
     NodeEngine nodeEngine = getNodeEngine();
-    int[] operationFactoryPartitions = partitionAwareFactory.getPartitions();
+    int[] operationFactoryPartitions = factory.getPartitions();
     partitions = operationFactoryPartitions == null ? partitions : operationFactoryPartitions;


Input:
public void setObject(Serializable object) {
    list.clear();
    if (object != null) {
        list.add(object.toString());
    }
}

Output:
     if (object != null) {
-        list.add(object.toString());
+        list.add(object);
     }


Input:
public Object clone() {
    final CacheMap<K, V> clone;
    try {
        clone = (CacheMap<K, V>) super.clone();
    } catch (CloneNotSupportedException e) {
        throw new InternalError();
    }
    clone._map = new LinkedHashMap<K, Value<V>>(clone._map);
    for (Map.Entry<K, Value<V>> me : clone._map.entrySet()) {
        me.setValue((Value<V>) me.getValue().clone());
    }
    clone.init();
    return clone;
}

Output:
     }
-    clone._map = new LinkedHashMap<K, Value<V>>(clone._map);
+    clone._inExpunge = false;
+    clone._map = new LinkedHashMap<K, Value<V>>(this._map);
     for (Map.Entry<K, Value<V>> me : clone._map.entrySet()) {


Input:
public void beforeDeleteNode(NodeRef nodeRef) {
    if (this.nodeService.exists(nodeRef) == true && this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_TAGGABLE) == true && this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_WORKING_COPY) == false) {
        updateAllScopeTags(nodeRef, Boolean.FALSE);
    }
}

Output:
 public void beforeDeleteNode(NodeRef nodeRef) {
-    if (this.nodeService.exists(nodeRef) == true && this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_TAGGABLE) == true && this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_WORKING_COPY) == false) {
+    if (this.nodeService.exists(nodeRef) == true && this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_TAGGABLE) == true) {
         updateAllScopeTags(nodeRef, Boolean.FALSE);


Input:
public void timestamp(BuckEvent event) {
    long nanos = clock.nanoTime();
    event.configure(TimeUnit.NANOSECONDS.toMillis(nanos), nanos, threadIdSupplier.get(), buildId);
}

Output:
 public void timestamp(BuckEvent event) {
-    long nanos = clock.nanoTime();
-    event.configure(TimeUnit.NANOSECONDS.toMillis(nanos), nanos, threadIdSupplier.get(), buildId);
+    event.configure(clock.currentTimeMillis(), clock.nanoTime(), threadIdSupplier.get(), buildId);
 }


Input:
public static Transaction fromByteReader(ByteReader reader, Sha256Hash knownTransactionHash) throws TransactionParsingException {
    int size = reader.available();
    try {
        int version = reader.getIntLE();
        int numInputs = (int) reader.getCompactInt();
        TransactionInput[] inputs = new TransactionInput[numInputs];
        for (int i = 0; i < numInputs; i++) {
            try {
                inputs[i] = TransactionInput.fromByteReader(reader);
            } catch (TransactionInputParsingException e) {
                throw new TransactionParsingException("String_Node_Str" + i + "String_Node_Str" + e.getMessage(), e);
            } catch (IllegalStateException e) {
                throw new TransactionParsingException("String_Node_Str" + i + "String_Node_Str" + e.getMessage(), e);
            }
        }
        int numOutputs = (int) reader.getCompactInt();
        TransactionOutput[] outputs = new TransactionOutput[numOutputs];
        for (int i = 0; i < numOutputs; i++) {
            try {
                outputs[i] = TransactionOutput.fromByteReader(reader);
            } catch (TransactionOutputParsingException e) {
                throw new TransactionParsingException("String_Node_Str" + i + "String_Node_Str" + e.getMessage(), e);
            }
        }
        int lockTime = reader.getIntLE();
        return new Transaction(version, inputs, outputs, lockTime, size, knownTransactionHash);
    } catch (InsufficientBytesException e) {
        throw new TransactionParsingException(e.getMessage());
    }
}

Output:
             } catch (TransactionOutputParsingException e) {
-                throw new TransactionParsingException("String_Node_Str" + i + "String_Node_Str" + e.getMessage(), e);
+                throw new TransactionParsingException("String_Node_Str" + i + "String_Node_Str" + e.getMessage());
             }