Input:
public void deleteEntities(List<AtlasVertex> instanceVertices) throws AtlasBaseException {
    RequestContextV1 requestContext = RequestContextV1.get();
    Set<AtlasVertex> deletionCandidateVertices = new HashSet<>();
    for (AtlasVertex instanceVertex : instanceVertices) {
        String guid = GraphHelper.getGuid(instanceVertex);
        AtlasEntity.Status state = AtlasGraphUtilsV1.getState(instanceVertex);
        if (requestContext.getDeletedEntityIds().contains(guid) || state == AtlasEntity.Status.DELETED) {
            LOG.debug("String_Node_Str", guid);
            continue;
        }
        Set<GraphHelper.VertexInfo> compositeVertices = getCompositeVertices(instanceVertex);
        for (GraphHelper.VertexInfo vertexInfo : compositeVertices) {
            requestContext.recordEntityDelete(vertexInfo.getGuid());
            deletionCandidateVertices.add(vertexInfo.getVertex());
        }
    }
    for (AtlasVertex deletionCandidateVertex : deletionCandidateVertices) {
        deleteAllTraits(deletionCandidateVertex);
        deleteTypeVertex(deletionCandidateVertex, false);
    }
}

Output:
         for (GraphHelper.VertexInfo vertexInfo : compositeVertices) {
-            requestContext.recordEntityDelete(vertexInfo.getGuid());
+            requestContext.recordEntityDelete(new AtlasObjectId(vertexInfo.getTypeName(), vertexInfo.getGuid()));
             deletionCandidateVertices.add(vertexInfo.getVertex());


Input:
public void onPlayerItem(PlayerItemEvent event) {
    Player player = event.getPlayer();
    int type = event.getMaterial().getId();
    if (!j2.hasFlag(player, Flag.MODWORLD)) {
        player.sendMessage("String_Node_Str");
        event.setCancelled(true);
        return;
    }
    if (j2.hasFlag(player, Flag.TRUSTED) && !j2.hasFlag(player, Flag.ADMIN) && j2.isOnSuperBlacklist(type)) {
        player.sendMessage(ChatColor.RED + "String_Node_Str");
        event.setCancelled(true);
        return;
    }
    if (!j2.hasFlag(player, Flag.TRUSTED) && (j2.isOnRegularBlacklist(type) || j2.isOnSuperBlacklist(type))) {
        player.sendMessage(ChatColor.RED + "String_Node_Str");
        event.setCancelled(true);
        return;
    }
    BlockRow changed;
    Block clicked = event.getBlockClicked();
    BlockFace face = event.getBlockFace();
    int x = clicked.getX() + face.getModX();
    int y = clicked.getY() + face.getModY();
    int z = clicked.getZ() + face.getModZ();
    changed = new BlockRow(player.getDisplayName(), event.getItem().getTypeId(), 0, x, y, z, (System.currentTimeMillis() / 1000L));
    managerBlockLog.bqueue.offer(changed);
}

Output:
     int z = clicked.getZ() + face.getModZ();
-    changed = new BlockRow(player.getDisplayName(), event.getItem().getTypeId(), 0, x, y, z, (System.currentTimeMillis() / 1000L));
-    managerBlockLog.bqueue.offer(changed);
+    if (type != 323) {
+        changed = new BlockRow(player.getDisplayName(), 0, type, x, y, z, (System.currentTimeMillis() / 1000L), null);
+        managerBlockLog.bqueue.offer(changed);
+    }
 }


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_edit_checking_account_transaction);
    showStandardToolbarActions();
    ITransactionEntity model = AccountTransaction.create();
    mCommonFunctions = new EditTransactionCommonFunctions(this, model);
    if ((savedInstanceState != null)) {
        restoreInstanceState(savedInstanceState);
    }
    mCommonFunctions.findControls(this);
    if (getIntent() != null) {
        boolean handled = handleIntent(savedInstanceState);
        if (!handled) {
            finish();
            return;
        }
    }
    initializeInputControls();
    mCommonFunctions.onTransactionTypeChanged(mCommonFunctions.transactionEntity.getTransactionType());
    mCommonFunctions.refreshPayeeName();
    mCommonFunctions.displayCategoryName();
}

Output:
     mCommonFunctions.onTransactionTypeChanged(mCommonFunctions.transactionEntity.getTransactionType());
-    mCommonFunctions.refreshPayeeName();
+    mCommonFunctions.showPayeeName();
     mCommonFunctions.displayCategoryName();


Input:
public void onPageSelected(int pos) {
    calc.getCurrUnitType().clearUnitSelection();
    updateScreen(false);
    calc.setUnitTypePos(pos);
}

Output:
 public void onPageSelected(int pos) {
-    calc.getCurrUnitType().clearUnitSelection();
+    mCalc.getCurrUnitType().clearUnitSelection();
     updateScreen(false);


Input:
public boolean usableAsReusableStructure() {
    return hasSingleClassSelector() || hasSingleIdSelector();
}

Output:
 public boolean usableAsReusableStructure() {
-    return hasSingleClassSelector() || hasSingleIdSelector();
+    for (Selector selector : selectors) {
+        if (isReusableSelector(selector))
+            return true;
+    }
+    return false;
 }


Input:
protected List<Sql> createIndexs(Entity<?> en) {
    List<Sql> sqls = new ArrayList<Sql>();
    StringBuilder sb = new StringBuilder();
    List<EntityIndex> indexs = en.getIndexes();
    for (EntityIndex index : indexs) {
        sb.setLength(0);
        if (index.isUnique())
            sb.append("String_Node_Str");
        else
            sb.append("String_Node_Str");
        sb.append(index.getName());
        sb.append("String_Node_Str").append(en.getTableName()).append("String_Node_Str");
        for (EntityField field : index.getFields()) {
            if (field instanceof MappingField) {
                MappingField mf = (MappingField) field;
                sb.append(mf.getColumnName()).append(',');
            } else {
                throw Lang.makeThrow(DaoException.class, "String_Node_Str", en.getClass(), field.getName());
            }
        }
        sb.setCharAt(sb.length() - 1, ')');
        sqls.add(Sqls.create(sb.toString()));
    }
    return sqls;
}

Output:
             sb.append("String_Node_Str");
-        sb.append(index.getName());
+        if (index.getName().contains("String_Node_Str"))
+            sb.append(TableName.render(new CharSegment(index.getName())));
+        else
+            sb.append(index.getName());
         sb.append("String_Node_Str").append(en.getTableName()).append("String_Node_Str");


Input:
public void setShowOffline(boolean isShowOffline) {
    Object selectedObject = null;
    int currentlySelectedIndex = this.getSelectedIndex();
    if (currentlySelectedIndex != -1) {
        selectedObject = listModel.getElementAt(currentlySelectedIndex);
    }
    int listSize = listModel.getSize();
    listModel.setShowOffline(isShowOffline);
    ConfigurationManager.setShowOffline(isShowOffline);
    int newListSize = listModel.getSize();
    if (!isShowOffline && listSize > 0) {
        if (newListSize > 0) {
            listModel.contentChanged(0, newListSize - 1);
            listModel.contentRemoved(newListSize - 1, listSize - 1);
        } else
            listModel.contentRemoved(0, listSize - 1);
    } else if (isShowOffline && newListSize > 0) {
        if (listSize > 0) {
            listModel.contentChanged(0, listSize - 1);
            listModel.contentAdded(listSize - 1, newListSize - 1);
        } else
            listModel.contentAdded(0, newListSize - 1);
    }
    if (selectedObject != null) {
        if (selectedObject instanceof MetaContact) {
            this.setSelectedIndex(listModel.indexOf(selectedObject));
        } else {
            this.setSelectedIndex(listModel.indexOf(selectedObject));
        }
    }
}

Output:
     if (selectedObject != null) {
-        if (selectedObject instanceof MetaContact) {
-            this.setSelectedIndex(listModel.indexOf(selectedObject));
-        } else {
-            this.setSelectedIndex(listModel.indexOf(selectedObject));
-        }
+        this.setSelectedIndex(listModel.indexOf(selectedObject));
     }


Input:
private void buildAnnotationRecordForOutput(String chromosome, int pos, int anno) {
    if (annotations.pastChosenAnnotation(anno, chromosome, pos)) {
        Annotation annoOut = annotations.getAnnotation(anno);
        FormatFieldCounter counter = counterMap.get(anno);
        StringBuilder lineToOutput = new StringBuilder("String_Node_Str");
        try {
            if (writeObservations) {
                identifiers[0] = "String_Node_Str";
                identifiers[1] = annoOut.getChromosome();
                identifiers[2] = String.valueOf(annoOut.getStart());
                identifiers[3] = String.valueOf(annoOut.getEnd());
                identifiers[4] = annoOut.getId();
                obsWriter.setElementIds(identifiers);
            }
            lineToOutput.append(annoOut.getChromosome());
            lineToOutput.append("String_Node_Str");
            lineToOutput.append(String.valueOf(annoOut.getStart()));
            lineToOutput.append("String_Node_Str");
            lineToOutput.append(String.valueOf(annoOut.getEnd())).append("String_Node_Str");
            lineToOutput.append(annoOut.getId());
            if (writeCounts) {
                for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                    for (int sampleIndex = 0; sampleIndex < numSamples; sampleIndex++) {
                        lineToOutput.append("String_Node_Str");
                        final int unMethylatedCCounterPerSample = counter.getUnmethylatedCCountPerSample(currentContext, sampleIndex);
                        lineToOutput.append(unMethylatedCCounterPerSample);
                    }
                }
                for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                    for (int sampleIndex = 0; sampleIndex < numSamples; sampleIndex++) {
                        lineToOutput.append("String_Node_Str");
                        final int methylatedCCounterPerSample = counter.getMethylatedCCountPerSample(currentContext, sampleIndex);
                        lineToOutput.append(methylatedCCounterPerSample);
                    }
                }
            }
            for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                for (int sampleIndex = 0; sampleIndex < numSamples; sampleIndex++) {
                    lineToOutput.append("String_Node_Str");
                    final double methylationRatePerSample = counter.getMethylationRatePerSample(currentContext, sampleIndex);
                    lineToOutput.append(formatDouble(methylationRatePerSample));
                }
            }
            if (writeCounts) {
                for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                    for (int groupIndex = 0; groupIndex < numGroups; groupIndex++) {
                        lineToOutput.append("String_Node_Str");
                        final int unMethylatedCCounterPerGroup = counter.getUnmethylatedCcountPerGroup(currentContext, groupIndex);
                        lineToOutput.append(unMethylatedCCounterPerGroup);
                    }
                }
                for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                    for (int groupIndex = 0; groupIndex < numGroups; groupIndex++) {
                        lineToOutput.append("String_Node_Str");
                        final int methylatedCCounterPerGroup = counter.getMethylatedCCountPerGroup(currentContext, groupIndex);
                        lineToOutput.append(methylatedCCounterPerGroup);
                    }
                }
            }
            for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                for (int groupIndex = 0; groupIndex < numGroups; groupIndex++) {
                    lineToOutput.append("String_Node_Str");
                    lineToOutput.append(formatDouble(counter.getMethylationRatePerGroup(currentContext, groupIndex)));
                }
            }
            if (writeNumSites) {
                for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                    for (int sampleIndex = 0; sampleIndex < numSamples; sampleIndex++) {
                        lineToOutput.append("String_Node_Str");
                        final int numSitesPerSample = counter.getNumberOfSitesPerSample(currentContext, sampleIndex);
                        lineToOutput.append(numSitesPerSample);
                    }
                }
                for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                    for (int groupIndex = 0; groupIndex < numGroups; groupIndex++) {
                        lineToOutput.append("String_Node_Str");
                        final int numSitesPerGroup = counter.getNumberOfSitesPerGroup(currentContext, groupIndex);
                        lineToOutput.append(numSitesPerGroup);
                    }
                }
            }
            for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                for (final GroupComparison comparison : groupComparisons) {
                    final int indexGroup1 = comparison.indexGroup1;
                    final int indexGroup2 = comparison.indexGroup2;
                    double fisherP = Double.NaN;
                    final boolean ok = checkCounts(counter, currentContext);
                    if (ok) {
                        fisherP = fisherRInstalled ? FisherExactRCalculator.getFisherPValue(counter.getUnmethylatedCcountPerGroup(currentContext, indexGroup1), counter.getMethylatedCCountPerGroup(currentContext, indexGroup1), counter.getUnmethylatedCcountPerGroup(currentContext, indexGroup2), counter.getMethylatedCCountPerGroup(currentContext, indexGroup2)) : Double.NaN;
                    } else {
                        LOG.error(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str", counter.getUnmethylatedCcountPerGroup(currentContext, indexGroup1), counter.getMethylatedCCountPerGroup(currentContext, indexGroup1), counter.getUnmethylatedCcountPerGroup(currentContext, indexGroup2), counter.getMethylatedCCountPerGroup(currentContext, indexGroup2)));
                    }
                    lineToOutput.append("String_Node_Str");
                    lineToOutput.append(formatDouble(fisherP));
                }
            }
            for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                for (final GroupComparison comparison : groupComparisons) {
                    final int indexGroup1 = comparison.indexGroup1;
                    final int indexGroup2 = comparison.indexGroup2;
                    final double deltaMR = Math.abs(counter.getMethylationRatePerGroup(currentContext, indexGroup1) - counter.getMethylationRatePerGroup(currentContext, indexGroup2));
                    lineToOutput.append("String_Node_Str");
                    lineToOutput.append(formatDouble(deltaMR));
                }
            }
            if (estimateIntraGroupDifferences) {
                obsWriter.setTypeOfPair(ObservationWriter.TypeOfPair.WITHIN_GROUP_PAIR);
                for (int currentContext = 0; currentContext < contexts.length; currentContext++) {
                    identifiers[0] = contexts[currentContext];
                    for (final GroupComparison comparison : groupComparisons) {
                        obsWriter.setNullComparison(comparison.nameGroup1);
                        empiricalPValueEstimator.estimateNullDensity(currentContext, comparison.indexGroup1, counter);
                        obsWriter.setNullComparison(comparison.nameGroup2);
                        empiricalPValueEstimator.estimateNullDensity(currentContext, comparison.indexGroup2, counter);
                    }
                }
            }
            if (estimateIntraGroupP) {
                obsWriter.setTypeOfPair(ObservationWriter.TypeOfPair.BETWEEN_GROUP_PAIR);
                for (int contextIndex = 0; contextIndex < contexts.length; contextIndex++) {
                    identifiers[0] = contexts[contextIndex];
                    for (final GroupComparison comparison : groupComparisons) {
                        obsWriter.setComparison(comparison);
                        final double p = empiricalPValueEstimator.estimateEmpiricalPValue(contextIndex, comparison, counter);
                        lineToOutput.append("String_Node_Str");
                        lineToOutput.append(formatDouble(p));
                    }
                }
            }
            outputWriter.append(lineToOutput.toString());
            outputWriter.append("String_Node_Str");
            counterMap.remove(anno);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

Output:
                     identifiers[0] = contexts[currentContext];
-                    for (final GroupComparison comparison : groupComparisons) {
-                        obsWriter.setNullComparison(comparison.nameGroup1);
-                        empiricalPValueEstimator.estimateNullDensity(currentContext, comparison.indexGroup1, counter);
-                        obsWriter.setNullComparison(comparison.nameGroup2);
-                        empiricalPValueEstimator.estimateNullDensity(currentContext, comparison.indexGroup2, counter);
+                    int groupIndex = 0;
+                    for (String group : groups) {
+                        empiricalPValueEstimator.estimateNullDensity(currentContext, groupIndex, counter);
+                        groupIndex++;
                     }


Input:
public void modifyText(ModifyEvent e) {
    String lowerStr = lowerText.getText();
    String higherStr = higherText.getText();
    if (lowerStr != "String_Node_Str" && !CheckValueUtils.isNumberWithNegativeValue(lowerStr)) {
        updateStatus(IStatus.ERROR, MSG_ONLY_NUMBER);
    } else if (!lowerStr.equals("String_Node_Str") && !higherStr.equals("String_Node_Str") && Double.valueOf(lowerStr) > Double.valueOf(higherStr)) {
        updateStatus(IStatus.ERROR, "String_Node_Str");
    } else {
        updateStatus(IStatus.OK, MSG_OK);
    }
    parameter.setMinThreshold(lowerStr);
}

Output:
     String higherStr = higherText.getText();
-    if (lowerStr != "String_Node_Str" && !CheckValueUtils.isNumberWithNegativeValue(lowerStr)) {
+    if (!lowerStr.equals("String_Node_Str") && !CheckValueUtils.isNumberWithNegativeValue(lowerStr)) {
         updateStatus(IStatus.ERROR, MSG_ONLY_NUMBER);


Input:
private void onEvent(SelectGroupReplyEvent event) {
    handleSelection(event.getTablePerspective(), event.getGroup());
    this.onAutomaticSwitch.on(target);
}

Output:
     handleSelection(event.getTablePerspective(), event.getGroup());
-    this.onAutomaticSwitch.on(target);
+    switchToTarget();
 }


Input:
public double applyCalibration(final double v, final double rangeIndex, final double azimuthIndex, final double slantRange, final double satelliteHeight, final double sceneToEarthCentre, final double localIncidenceAngle, final String bandPolar, final Unit.UnitType bandUnit, int[] subSwathIndex) {
    final String targetBandName = "String_Node_Str" + bandPolar.toUpperCase();
    final CalibrationInfo calInfo = targetBandToCalInfo.get(targetBandName);
    final int calVecIdx = calInfo.getCalibrationVectorIndex((int) azimuthIndex);
    final Sentinel1Utils.CalibrationVector vec0 = calInfo.getCalibrationVector(calVecIdx);
    final Sentinel1Utils.CalibrationVector vec1 = calInfo.getCalibrationVector(calVecIdx + 1);
    final CALTYPE calType = getCalibrationType(targetBandName);
    final float[] vec0LUT = getVector(calType, vec0);
    final float[] vec1LUT = getVector(calType, vec1);
    final int pixelIdx = calInfo.getPixelIndex((int) rangeIndex, calVecIdx);
    final double azTime = calInfo.firstLineTime + azimuthIndex * calInfo.lineTimeInterval;
    final double muY = (azTime - vec0.timeMJD) / (vec1.timeMJD - vec0.timeMJD);
    final double muX = (rangeIndex - vec0.pixels[pixelIdx]) / (double) (vec0.pixels[pixelIdx + 1] - vec0.pixels[pixelIdx]);
    final double lutVal = (1 - muY) * ((1 - muX) * vec0LUT[pixelIdx] + muX * vec0LUT[pixelIdx + 1]) + muY * ((1 - muX) * vec1LUT[pixelIdx] + muX * vec1LUT[pixelIdx + 1]);
    double sigma = 0.0;
    if (bandUnit == Unit.UnitType.AMPLITUDE) {
        sigma = v * v / (lutVal * lutVal);
    } else if (bandUnit == Unit.UnitType.INTENSITY) {
        sigma = v / (lutVal * lutVal);
    } else if (bandUnit == Unit.UnitType.INTENSITY_DB) {
        sigma = FastMath.pow(10, v / 10.0) / (lutVal * lutVal);
    } else if (bandUnit == Unit.UnitType.REAL || bandUnit == Unit.UnitType.IMAGINARY) {
        sigma = v / lutVal;
    } else {
        throw new OperatorException("String_Node_Str");
    }
    return sigma;
}

Output:
     final Sentinel1Utils.CalibrationVector vec1 = calInfo.getCalibrationVector(calVecIdx + 1);
-    final CALTYPE calType = getCalibrationType(targetBandName);
+    final CALTYPE calType = getCalibrationType(bandName);
     final float[] vec0LUT = getVector(calType, vec0);


Input:
private Link getActionLink(String actionName) {
    Link result = null;
    try {
        WebElement link = Utils.waitForFind(row, getActionSelector(actionName));
        result = new Link(link);
    } catch (NoSuchElementException e) {
    }
    return result;
}

Output:
         result = new Link(link);
-    } catch (NoSuchElementException e) {
+    } catch (TimeoutException e) {
     }


Input:
public Collection<UniqueConstraint> uniqueConstraints() {
    return uniqueConstraints.values();
}

Output:
 public Collection<UniqueConstraint> uniqueConstraints() {
-    return uniqueConstraints.values();
+    return Collections.unmodifiableCollection(uniqueConstraints.values());
 }


Input:
public ExecutionResult execute(Item item) {
    if (item instanceof LDAPSchemaConnectionItem) {
        Connection connection = ((LDAPSchemaConnectionItem) item).getConnection();
        if (connection instanceof LDAPSchemaConnection) {
            LDAPSchemaConnection ldapConn = (LDAPSchemaConnection) connection;
            try {
                if (!ldapConn.isContextMode()) {
                    String pass = ldapConn.getBindPassword();
                    ldapConn.setBindPassword(ldapConn.getValue(pass, true));
                    factory.save(item, true);
                }
            } catch (Exception e) {
                ExceptionHandler.process(e);
                return ExecutionResult.FAILURE;
            }
        }
    }
    return ExecutionResult.SUCCESS_NO_ALERT;
}

Output:
     }
-    return ExecutionResult.SUCCESS_NO_ALERT;
+    return ExecutionResult.NOTHING_TO_DO;
 }


Input:
protected final void powder(final SnipeData v) {
    if (originCoords == null) {
        v.owner().getPlayer().sendMessage(ChatColor.RED + "String_Node_Str");
        return;
    } else {
        targetCoords.setX(this.getTargetBlock().getX() + .5 * this.getTargetBlock().getX() / Math.abs(this.getTargetBlock().getX()));
        targetCoords.setY(this.getTargetBlock().getY() + .5);
        targetCoords.setZ(this.getTargetBlock().getZ() + .5 * this.getTargetBlock().getZ() / Math.abs(this.getTargetBlock().getZ()));
        this.linePowder(v);
    }
}

Output:
 protected final void powder(final SnipeData v) {
-    if (originCoords == null) {
+    if (this.originCoords == null || !this.getTargetBlock().getWorld().equals(this.targetWorld)) {
         v.owner().getPlayer().sendMessage(ChatColor.RED + "String_Node_Str");


Input:
public void logChat(Player player) {
    String name = player.getName();
    if (chatLevel.get(name) == null) {
        logEventNoCheck(chatLevel, player, 1, CHAT_MIN);
    } else {
        int amount = chatLevel.get(name) + 1;
        chatLevel.put(name, amount);
        checkChatLevel(player, amount);
    }
}

Output:
     if (chatLevel.get(name) == null) {
-        logEventNoCheck(chatLevel, player, 1, CHAT_MIN);
+        logEvent(chatLevel, player, 1, CHAT_MIN);
     } else {


Input:
public int getStorageCount(ItemStack storage, ItemStack addition, boolean allowPartial) {
    if (addition == null)
        return 0;
    else if (storage == null)
        return addition.getAmount();
    else if (storage.getType() != Material.AIR && !hasSameItem(storage, addition))
        return 0;
    int sum = storage.getAmount() + addition.getAmount();
    int max = storage.getType().getMaxStackSize();
    if (sum > max) {
        return allowPartial ? max - storage.getAmount() : 0;
    } else {
        return addition.getAmount();
    }
}

Output:
         return addition.getAmount();
-    else if (storage.getType() != Material.AIR && !hasSameItem(storage, addition))
+    else if (!isAir && !hasSameItem(storage, addition))
         return 0;


Input:
public void execute(AdminCommandContext context) {
    final ActionReport report = context.getActionReport();
    List<Config> configList = configs.getConfig();
    Config config = configList.get(0);
    SecurityService securityService = config.getSecurityService();
    AuthRealm fileAuthRealm = null;
    for (AuthRealm authRealm : securityService.getAuthRealm()) {
        if (authRealm.getName().equals(ADMIN_REALM)) {
            fileAuthRealm = authRealm;
            break;
        }
    }
    if (fileAuthRealm == null) {
        report.setMessage(localStrings.getLocalString("String_Node_Str", "String_Node_Str" + "String_Node_Str"));
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        return;
    }
    String fileRealmClassName = fileAuthRealm.getClassname();
    if (fileRealmClassName != null && !fileRealmClassName.equals("String_Node_Str")) {
        report.setMessage(localStrings.getLocalString("String_Node_Str", "String_Node_Str"));
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        return;
    }
    String keyFile = null;
    for (Property fileProp : fileAuthRealm.getProperty()) {
        if (fileProp.getName().equals("String_Node_Str"))
            keyFile = fileProp.getValue();
    }
    if (keyFile == null) {
        report.setMessage(localStrings.getLocalString("String_Node_Str", "String_Node_Str"));
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        return;
    }
    FileRealm fr = null;
    try {
        realmsManager.createRealms(config);
        fr = (FileRealm) realmsManager.getFromLoadedRealms(config.getName(), fileAuthRealm.getName());
        if (fr == null) {
            throw new NoSuchRealmException(fileAuthRealm.getName());
        }
    } catch (NoSuchRealmException e) {
        report.setMessage(localStrings.getLocalString("String_Node_Str", "String_Node_Str") + "String_Node_Str" + e.getLocalizedMessage());
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        report.setFailureCause(e);
        return;
    }
    try {
        Enumeration en = fr.getGroupNames(userName);
        int size = 0;
        while (en.hasMoreElements()) {
            size++;
            en.nextElement();
        }
        String[] groups = new String[size];
        en = fr.getGroupNames(userName);
        for (int i = 0; i < size; i++) {
            groups[i] = (String) en.nextElement();
        }
        fr.updateUser(userName, userName, newpassword.toCharArray(), groups);
        fr.writeKeyFile(keyFile);
        report.setActionExitCode(ActionReport.ExitCode.SUCCESS);
    } catch (Exception e) {
        report.setMessage(localStrings.getLocalString("String_Node_Str", "String_Node_Str", userName) + "String_Node_Str" + e.getLocalizedMessage());
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        report.setFailureCause(e);
    }
}

Output:
     for (AuthRealm authRealm : securityService.getAuthRealm()) {
-        if (authRealm.getName().equals(ADMIN_REALM)) {
+        if (authRealm.getName().equals(adminService.getAuthRealmName())) {
             fileAuthRealm = authRealm;


Input:
private List<Variant> canonicalizeVariant(Variant variant, boolean end) {
    List<Variant> variantList = new ArrayList<>();
    boolean noSplit = false;
    if (variant.getType() == VariantOverallType.SNP) {
        noSplit = true;
    }
    if (variant.getCompositions() == null && variant.getGoodPaternal() == 0 && variant.getGoodMaternal() == 0) {
        noSplit = true;
    }
    if (variant.getGoodPaternal() != 0 && !canonicalizableFlexSeqTypes.contains(variant.getAlt(variant.getGoodPaternal()).getSeqType())) {
        noSplit = true;
    }
    if (variant.getGoodMaternal() != 0 && !canonicalizableFlexSeqTypes.contains(variant.getAlt(variant.getGoodMaternal()).getSeqType())) {
        noSplit = true;
    }
    if (variant.getGoodPaternal() != 0 && variant.getAlt(variant.getGoodPaternal()).length() == 0 && variant.getReference().length == 0) {
        noSplit = true;
    }
    if (variant.getGoodMaternal() > 0 && variant.getAlt(variant.getGoodMaternal()).length() == 0 && variant.getReference().length == 0) {
        noSplit = true;
    }
    if (noSplit) {
        variantList.add(variant);
        return variantList;
    }
    if (variant.getCompositions() != null) {
        for (Variant c : variant.getCompositions()) {
            variantList.addAll(canonicalizeVariant(new Variant(c), end));
        }
        return variantList;
    }
    Variant.Builder template = new Variant.Builder().chr(variant.getChr()).isPhased(true).varId(variant.getVariantId()).filter(VCFparser.DEFAULT_FILTER).refDeleted("String_Node_Str");
    if (variant.getType(variant.getGoodMaternal()) == VariantType.Translocation_Duplication || variant.getType(variant.getGoodMaternal()) == VariantType.Interspersed_Duplication || variant.getType(variant.getGoodPaternal()) == VariantType.Translocation_Duplication || variant.getType(variant.getGoodPaternal()) == VariantType.Interspersed_Duplication) {
        for (int parentIndex = 0; parentIndex < 2; parentIndex++) {
            int allele = variant.getAllele(parentIndex);
            if (variant.getType(allele) == VariantType.Reference)
                continue;
            byte[] phase = new byte[2];
            phase[parentIndex] = 1;
            if (variant.getType(allele) == VariantType.Translocation_Duplication || variant.getType(allele) == VariantType.Interspersed_Duplication) {
                boolean isInversed = variant.isInversed();
                Alt alt1 = new Alt();
                alt1.setBreakend(new Alt.Breakend(variant.getReference().clone(), variant.getChr2(allele), isInversed ? variant.getEnd2(allele) : variant.getPos2(allele), true, !isInversed));
                variantList.add(template.pos(variant.getPos() - 1).referenceAlleleLength(0).ref(new byte[] { 'N' }).alts(new Alt[] { alt1 }).phase(phase).build());
                Alt alt2 = new Alt();
                alt2.setBreakend(new Alt.Breakend(ambiguousBase, variant.getChr2(parentIndex), isInversed ? variant.getPos2(parentIndex) : variant.getEnd2(parentIndex), false, isInversed));
                variantList.add(template.pos(variant.getPos()).referenceAlleleLength(0).ref(new byte[] { 'N' }).alts(new Alt[] { alt2 }).phase(phase).build());
            }
            variant.setAllele(parentIndex, (byte) 0);
        }
    } else if (variant.getType(variant.getGoodMaternal()) == VariantType.Translocation_Deletion || variant.getType(variant.getGoodPaternal()) == VariantType.Translocation_Deletion) {
        for (int parentIndex = 0; parentIndex < 2; parentIndex++) {
            int allele = variant.getAllele(parentIndex);
            if (variant.getType(allele) == VariantType.Reference)
                continue;
            byte[] phase = new byte[2];
            phase[parentIndex] = 1;
            if (variant.getType(allele) == VariantType.Translocation_Deletion) {
                Alt alt1 = new Alt();
                alt1.setBreakend(new Alt.Breakend(variant.getReference().clone(), variant.getChr(), variant.getPos() + variant.getReferenceAlleleLength(), true, true));
                variantList.add(template.pos(variant.getPos() - 1).referenceAlleleLength(0).ref(new byte[] { 'N' }).alts(new Alt[] { alt1 }).phase(phase).build());
            }
            variant.setAllele(parentIndex, (byte) 0);
        }
    } else if (variant.getType(variant.getGoodPaternal()) != VariantType.Reference && variant.getType(variant.getGoodMaternal()) != VariantType.Reference) {
        int[] alleleNumber = { variant.getAllele(0), variant.getAllele(1) };
        byte[][] alternativeAlleleSequence = { variant.getAlt(alleleNumber[0]).getSequence(), variant.getAlt(alleleNumber[1]).getSequence() };
        byte[] referenceAlleleSequence = variant.getReference();
        int currentPosition = variant.getPos();
        int minMatchLength = variant.getMinMatchLength();
        if (minMatchLength > 0) {
            referenceAlleleSequence = Arrays.copyOfRange(referenceAlleleSequence, minMatchLength, referenceAlleleSequence.length);
            for (int i = 0; i < 2; i++) {
                alternativeAlleleSequence[i] = Arrays.copyOfRange(alternativeAlleleSequence[i], minMatchLength, alternativeAlleleSequence[i].length);
            }
            currentPosition += minMatchLength;
        }
        int[] alleleLengthDifference = { alternativeAlleleSequence[0].length - referenceAlleleSequence.length, alternativeAlleleSequence[1].length - referenceAlleleSequence.length };
        canonicalizeToIndels(variantList, alleleLengthDifference, referenceAlleleSequence, alternativeAlleleSequence, variant, currentPosition, end);
        for (int relativePosition = 0; relativePosition < referenceAlleleSequence.length; relativePosition++, currentPosition++) {
            int[] alleleSpecificRelativePosition = new int[2];
            if (end) {
                for (int j = 0; j < 2; j++) {
                    if (relativePosition < referenceAlleleSequence.length + alleleLengthDifference[j]) {
                        alleleSpecificRelativePosition[j] = relativePosition;
                    } else {
                        alleleSpecificRelativePosition[j] = -1;
                    }
                }
            } else {
                for (int j = 0; j < 2; j++) {
                    alleleSpecificRelativePosition[j] = relativePosition + alleleLengthDifference[j];
                }
            }
            if (alleleSpecificRelativePosition[0] < 0 && alleleSpecificRelativePosition[1] < 0) {
            } else if (alleleSpecificRelativePosition[0] >= 0 && alleleSpecificRelativePosition[1] < 0 && alternativeAlleleSequence[0][alleleSpecificRelativePosition[0]] != referenceAlleleSequence[relativePosition]) {
                byte[] phase = { 1, 1 };
                Alt alt = new Alt();
                alt.setSeq(new FlexSeq(alternativeAlleleSequence[0][alleleSpecificRelativePosition[0]]));
                variantList.add(template.pos(currentPosition).referenceAlleleLength(1).ref(new byte[] { referenceAlleleSequence[relativePosition] }).alts(new Alt[] { alt }).phase(phase).build());
            } else if (alleleSpecificRelativePosition[0] < 0 && alleleSpecificRelativePosition[1] >= 0 && alternativeAlleleSequence[1][alleleSpecificRelativePosition[1]] != referenceAlleleSequence[relativePosition]) {
                byte[] phase = { 1, 1 };
                Alt alt = new Alt();
                alt.setSeq(new FlexSeq(alternativeAlleleSequence[1][alleleSpecificRelativePosition[1]]));
                variantList.add(template.pos(currentPosition).referenceAlleleLength(1).ref(new byte[] { referenceAlleleSequence[relativePosition] }).alts(new Alt[] { alt }).phase(phase).build());
            } else if (alleleSpecificRelativePosition[0] >= 0 && alleleSpecificRelativePosition[1] < 0 && alternativeAlleleSequence[0][alleleSpecificRelativePosition[0]] == referenceAlleleSequence[relativePosition]) {
            } else if (alleleSpecificRelativePosition[0] < 0 && alleleSpecificRelativePosition[1] >= 0 && alternativeAlleleSequence[1][alleleSpecificRelativePosition[1]] == referenceAlleleSequence[relativePosition]) {
            } else if (alternativeAlleleSequence[0][alleleSpecificRelativePosition[0]] == referenceAlleleSequence[relativePosition] && alternativeAlleleSequence[1][alleleSpecificRelativePosition[1]] == referenceAlleleSequence[relativePosition]) {
            } else if (alternativeAlleleSequence[0][alleleSpecificRelativePosition[0]] == alternativeAlleleSequence[1][alleleSpecificRelativePosition[1]]) {
                byte[] phase = { 1, 1 };
                Alt alt = new Alt();
                alt.setSeq(new FlexSeq(alternativeAlleleSequence[0][alleleSpecificRelativePosition[0]]));
                variantList.add(template.pos(currentPosition).referenceAlleleLength(1).ref(new byte[] { referenceAlleleSequence[relativePosition] }).alts(new Alt[] { alt }).phase(phase).build());
            } else if (alternativeAlleleSequence[0][alleleSpecificRelativePosition[0]] != referenceAlleleSequence[relativePosition] && alternativeAlleleSequence[1][alleleSpecificRelativePosition[1]] != referenceAlleleSequence[relativePosition]) {
                byte[] phase = { 1, 2 };
                Alt[] alts = new Alt[2];
                alts[0] = new Alt();
                alts[1] = new Alt();
                alts[0].setSeq(new FlexSeq(alternativeAlleleSequence[0][alleleSpecificRelativePosition[0]]));
                alts[1].setSeq(new FlexSeq(alternativeAlleleSequence[1][alleleSpecificRelativePosition[1]]));
                variantList.add(template.pos(currentPosition).referenceAlleleLength(1).ref(new byte[] { referenceAlleleSequence[relativePosition] }).alts(alts).phase(phase).build());
            } else {
                for (int a = 0; a < 2; a++) {
                    if (alternativeAlleleSequence[a][alleleSpecificRelativePosition[a]] != referenceAlleleSequence[relativePosition]) {
                        byte[] phase = { 0, 0 };
                        phase[a] = 1;
                        Alt alt = new Alt();
                        alt.setSeq(new FlexSeq(alternativeAlleleSequence[a][alleleSpecificRelativePosition[a]]));
                        variantList.add(template.pos(currentPosition).referenceAlleleLength(1).ref(new byte[] { referenceAlleleSequence[relativePosition] }).alts(new Alt[] { alt }).phase(phase).build());
                    }
                }
            }
        }
        variant.setAllele(0, (byte) 0);
        variant.setAllele(1, (byte) 0);
    } else {
        for (int alleleIndex = 0; alleleIndex < 2; alleleIndex++) {
            int allele = variant.getAllele(alleleIndex);
            if (variant.getType(allele) == VariantType.Complex || variant.getType(allele) == VariantType.MNP || variant.getType(allele) == VariantType.SNP) {
                byte[] alternativeAlleleSequence = variant.getAlt(allele).getSequence();
                byte[] referenceSequence = variant.getReference();
                int currentPosition = variant.getPos();
                int alleleLengthDifference = alternativeAlleleSequence.length - referenceSequence.length;
                if (alleleLengthDifference > 0) {
                    byte[] phase = { 0, 0 };
                    phase[alleleIndex] = 1;
                    if (end) {
                        Alt alt = new Alt();
                        alt.setSeq(new FlexSeq(Arrays.copyOfRange(alternativeAlleleSequence, 0, alleleLengthDifference)));
                        variantList.add(template.pos(currentPosition + referenceSequence.length).referenceAlleleLength(0).ref(new byte[] { 'N' }).alts(new Alt[] { alt }).phase(phase).build());
                    } else {
                        Alt alt = new Alt();
                        alt.setSeq(new FlexSeq(Arrays.copyOfRange(alternativeAlleleSequence, 0, alleleLengthDifference)));
                        variantList.add(template.pos(currentPosition).referenceAlleleLength(0).ref(new byte[] { 'N' }).alts(new Alt[] { alt }).phase(phase).build());
                    }
                } else if (alleleLengthDifference < 0) {
                    byte[] phase = { 0, 0 };
                    phase[alleleIndex] = 1;
                    if (end) {
                        Alt alt = new Alt();
                        alt.setSeq(new FlexSeq());
                        variantList.add(template.pos(currentPosition + alternativeAlleleSequence.length).referenceAlleleLength(-alleleLengthDifference).ref(Arrays.copyOfRange(referenceSequence, alternativeAlleleSequence.length, alternativeAlleleSequence.length - alleleLengthDifference)).alts(new Alt[] { alt }).phase(phase).build());
                    } else {
                        Alt alt = new Alt();
                        alt.setSeq(new FlexSeq());
                        variantList.add(template.pos(currentPosition).referenceAlleleLength(-alleleLengthDifference).ref(Arrays.copyOfRange(referenceSequence, 0, -alleleLengthDifference)).alts(new Alt[] { alt }).phase(phase).build());
                    }
                }
                for (int i = 0; i < referenceSequence.length; i++) {
                    int idx;
                    if (end) {
                        if (i < referenceSequence.length + alleleLengthDifference) {
                            idx = i;
                        } else {
                            idx = -1;
                        }
                    } else {
                        idx = i + alleleLengthDifference;
                    }
                    if (idx >= 0 && alternativeAlleleSequence[idx] != referenceSequence[i]) {
                        byte[] phase = { 0, 0 };
                        phase[alleleIndex] = 1;
                        Alt alt = new Alt();
                        alt.setSeq(new FlexSeq(alternativeAlleleSequence[idx]));
                        variantList.add(template.pos(currentPosition).referenceAlleleLength(1).ref(new byte[] { referenceSequence[i] }).alts(new Alt[] { alt }).phase(phase).build());
                    }
                    currentPosition++;
                }
                variant.setAllele(alleleIndex, (byte) 0);
            }
        }
    }
    if (!variant.isRef()) {
        variantList.add(variant);
    }
    return variantList;
}

Output:
     }
-    if (variant.getGoodPaternal() != 0 && !canonicalizableFlexSeqTypes.contains(variant.getAlt(variant.getGoodPaternal()).getSeqType())) {
+    if (variant.getGoodPaternal() > 0 && !canonicalizableFlexSeqTypes.contains(variant.getAlt(variant.getGoodPaternal()).getSeqType())) {
         noSplit = true;


Input:
public void widgetDisposed(DisposeEvent e) {
    if (!PlatformUI.getWorkbench().isClosing())
        e.widget.dispose();
}

Output:
 public void widgetDisposed(DisposeEvent e) {
-    if (!PlatformUI.getWorkbench().isClosing())
-        e.widget.dispose();
+    if (!PlatformUI.getWorkbench().isClosing()) {
+        fireDispose(SWTGLCanvas.this.canvas);
+        SWTGLCanvas.this.canvas.getContext().destroy();
+        SWTGLCanvas.this.canvas.setRealized(false);
+    }
 }


Input:
public void testXmlTransientOnProperty() {
    if (shouldGenerateSchema) {
        outputResolver = generateSchema(CONTEXT_PATH, 1);
        shouldGenerateSchema = false;
    }
    String result = validateAgainstSchema(PATH + "String_Node_Str", null, outputResolver);
    assertTrue("String_Node_Str", result != null);
}

Output:
     if (shouldGenerateSchema) {
-        outputResolver = generateSchema(CONTEXT_PATH, 1);
+        outputResolver = generateSchema(CONTEXT_PATH, PATH, 1);
         shouldGenerateSchema = false;


Input:
private static void changeBanner(EntityManager em, Integer posB, Object model, FlexibleElement flexibleElt) {
    LayoutGroup bannerGroup = null;
    if (model instanceof ProjectModel)
        bannerGroup = ((ProjectModel) model).getProjectBanner().getLayout().getGroups().get(posB);
    else if (model instanceof OrgUnitModel)
        bannerGroup = ((OrgUnitModel) model).getBanner().getLayout().getGroups().get(posB);
    LayoutConstraint newLayoutConstraint = null;
    boolean positionTaken = false;
    for (LayoutConstraint lc : bannerGroup.getConstraints()) {
        if (posB.equals(lc.getSortOrder())) {
            positionTaken = true;
            newLayoutConstraint = lc;
            lc.setElement(flexibleElt);
            newLayoutConstraint = em.merge(lc);
        }
    }
    if (!positionTaken) {
        newLayoutConstraint = new LayoutConstraint();
        newLayoutConstraint.setElement(flexibleElt);
        newLayoutConstraint.setParentLayoutGroup(bannerGroup);
        newLayoutConstraint.setSortOrder(new Integer(posB));
        em.persist(newLayoutConstraint);
    }
}

Output:
         newLayoutConstraint.setParentLayoutGroup(bannerGroup);
-        newLayoutConstraint.setSortOrder(new Integer(posB));
+        newLayoutConstraint.setSortOrder(new Integer(posB + 1));
         em.persist(newLayoutConstraint);


Input:
public EndpointState unfairTransform() {
    EndpointState init = this.clone();
    EndpointState term = ModelState.getTerminal(init);
    Set<EndpointState> seen = new HashSet<>();
    Set<EndpointState> todo = new LinkedHashSet<>();
    todo.add(init);
    while (!todo.isEmpty()) {
        Iterator<EndpointState> i = todo.iterator();
        EndpointState curr = i.next();
        i.remove();
        if (seen.contains(curr)) {
            continue;
        }
        seen.add(curr);
        if (curr.getStateKind() == Kind.OUTPUT && curr.getAllTakeable().size() > 1) {
            {
                Iterator<IOAction> as = curr.getAllTakeable().iterator();
                Iterator<EndpointState> ss = curr.getSuccessors().iterator();
                List<IOAction> cloneas = new LinkedList<>();
                List<EndpointState> cloness = new LinkedList<>();
                Map<EndpointState, IOAction> toRemove = new HashMap<>();
                while (as.hasNext()) {
                    IOAction a = as.next();
                    EndpointState s = ss.next();
                    if (!s.canReach(curr)) {
                        todo.add(s);
                    } else {
                        EndpointState clone = curr.unfairClone(term, a, s);
                        cloneas.add(a);
                        cloness.add(clone);
                        toRemove.put(s, a);
                    }
                }
                if (!cloneas.isEmpty()) {
                    for (EndpointState s : toRemove.keySet()) {
                        try {
                            curr.removeEdge(toRemove.get(s), s);
                        } catch (ScribbleException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    Iterator<IOAction> icloneas = cloneas.iterator();
                    Iterator<EndpointState> icloness = cloness.iterator();
                    while (icloneas.hasNext()) {
                        IOAction a = icloneas.next();
                        EndpointState s = icloness.next();
                        curr.addEdge(a, s);
                        todo.add(s);
                    }
                }
            }
        } else {
            todo.addAll(curr.getSuccessors());
        }
    }
    return init;
}

Output:
                 List<EndpointState> cloness = new LinkedList<>();
-                Map<EndpointState, IOAction> toRemove = new HashMap<>();
+                Map<EndpointState, List<IOAction>> toRemove = new HashMap<>();
                 while (as.hasNext()) {


Input:
public void onTextChanged(CharSequence s, int start, int before, int count) {
    String tmp = s.toString();
    if (tmp.contains("String_Node_Str")) {
        String[] strs = tmp.split("String_Node_Str");
        if (strs.length > 1 && strs[1].length() > 2) {
            eEtInMoney.setText(tmp.substring(0, tmp.length() - 1));
            eEtInMoney.setSelection(tmp.length() - 1);
        }
    }
    if (!TextUtils.isEmpty(tmp)) {
        double money = Double.parseDouble(tmp);
        if (money > Double.parseDouble(mTvOutAccountLeftMoney.getText().toString())) {
            KeyBoardUtils.closeKeybord(eEtInMoney, AccountsTransferActivity.this);
            SnackBarUtil.showSnackInfo(floatingActionButton, AccountsTransferActivity.this, getResources().getString(R.string.not_have_enough_money));
            eEtInMoney.setText(mTvOutAccountLeftMoney.getText());
        }
    }
}

Output:
         if (strs.length > 1 && strs[1].length() > 2) {
-            eEtInMoney.setText(tmp.substring(0, tmp.length() - 1));
-            eEtInMoney.setSelection(tmp.length() - 1);
+            eEtOutMoney.setText(tmp.substring(0, tmp.length() - 1));
+            eEtOutMoney.setSelection(tmp.length() - 1);
         }


Input:
public void render(GLRenderer renderer, RenderProps props, int flags) {
    GL2 gl = renderer.getGL2();
    offsetMag = 1.0 * renderer.centerDistancePerPixel();
    renderer.getZDirection();
    Vector3d offDir = new Vector3d(renderer.getZDirection());
    double scale = offsetMag / offDir.norm();
    offDir.scale(scale);
    if (myRenderSegments != null) {
        for (LineSeg seg : myRenderSegments) {
            renderer.drawLine(props, seg.coords0, seg.coords1, false);
        }
    }
    if (drawIntersectionContour && props.getEdgeWidth() > 0 && myRenderContactInfo != null) {
        gl.glLineWidth(props.getEdgeWidth());
        float[] rgb = props.getEdgeColorArray();
        if (rgb == null) {
            rgb = props.getLineColorArray();
        }
        renderer.setColor(rgb, false);
        renderer.setLightingEnabled(false);
        if (myRenderContactInfo.contours != null) {
            for (MeshIntersectionContour contour : myRenderContactInfo.contours) {
                gl.glBegin(GL2.GL_LINE_LOOP);
                for (MeshIntersectionPoint p : contour) {
                    gl.glVertex3d(p.x + offDir.x, p.y + offDir.y, p.z + offDir.z);
                }
                gl.glEnd();
            }
        } else if (myRenderContactInfo.intersections != null) {
            gl.glBegin(GL2.GL_LINES);
            for (TriTriIntersection tsect : myRenderContactInfo.intersections) {
                gl.glVertex3d(tsect.points[0].x + offDir.x, tsect.points[0].y + offDir.y, tsect.points[0].z + offDir.z);
                gl.glVertex3d(tsect.points[1].x + offDir.x, tsect.points[1].y + offDir.y, tsect.points[1].z + offDir.z);
            }
            gl.glEnd();
        }
        renderer.setLightingEnabled(true);
        gl.glLineWidth(1);
    }
    float[] coords = new float[3];
    if (drawIntersectionPoints && myRenderContactInfo != null) {
        if (myRenderContactInfo.intersections != null) {
            for (TriTriIntersection tsect : myRenderContactInfo.intersections) {
                for (Point3d pnt : tsect.points) {
                    pnt.get(coords);
                    renderer.drawPoint(props, coords, false);
                }
            }
        }
        if (myRenderContactInfo.points0 != null) {
            for (ContactPenetratingPoint cpp : myRenderContactInfo.points0) {
                if (cpp.distance > 0) {
                    cpp.vertex.getWorldPoint().get(coords);
                    renderer.drawPoint(props, coords, false);
                }
            }
        }
        if (myRenderContactInfo.points1 != null) {
            for (ContactPenetratingPoint cpp : myRenderContactInfo.points1) {
                if (cpp.distance > 0) {
                    cpp.vertex.getWorldPoint().get(coords);
                    renderer.drawPoint(props, coords, false);
                }
            }
        }
        if (myRenderContactInfo.edgeEdgeContacts != null) {
            for (EdgeEdgeContact eec : myRenderContactInfo.edgeEdgeContacts) {
                eec.point0.get(coords);
                renderer.drawPoint(props, coords, false);
                eec.point1.get(coords);
                renderer.drawPoint(props, coords, false);
            }
        }
    }
    if (drawIntersectionFaces && myRenderFaces != null) {
        gl.glPushMatrix();
        Material faceMat = props.getFaceMaterial();
        Shading shading = props.getShading();
        if (shading != Shading.NONE) {
            faceMat.apply(gl, GL2.GL_FRONT_AND_BACK);
            gl.glLightModelf(GL2.GL_LIGHT_MODEL_TWO_SIDE, 1);
        }
        if (props.getFaceStyle() != RenderProps.Faces.NONE) {
            int[] savedShadeModel = new int[1];
            gl.glGetIntegerv(GL2.GL_SHADE_MODEL, savedShadeModel, 0);
            if (shading == Shading.NONE) {
                renderer.setLightingEnabled(false);
                renderer.setColor(props.getFaceColorArray(), false);
            } else if (shading != Shading.FLAT && !renderer.isSelecting()) {
                gl.glShadeModel(GL2.GL_SMOOTH);
            } else {
                gl.glShadeModel(GL2.GL_FLAT);
            }
            byte[] savedCullFaceEnabled = new byte[1];
            int[] savedCullFaceMode = new int[1];
            gl.glGetBooleanv(GL2.GL_CULL_FACE, savedCullFaceEnabled, 0);
            gl.glGetIntegerv(GL2.GL_CULL_FACE_MODE, savedCullFaceMode, 0);
            RenderProps.Faces faces = props.getFaceStyle();
            switch(faces) {
                case FRONT_AND_BACK:
                    {
                        gl.glDisable(GL2.GL_CULL_FACE);
                        break;
                    }
                case FRONT:
                    {
                        gl.glCullFace(GL2.GL_BACK);
                        break;
                    }
                case BACK:
                    {
                        gl.glCullFace(GL2.GL_FRONT);
                        break;
                    }
                default:
                    break;
            }
            offDir.scale(0.5);
            gl.glBegin(GL2.GL_TRIANGLES);
            for (FaceSeg seg : myRenderFaces) {
                gl.glNormal3d(seg.nrm.x, seg.nrm.y, seg.nrm.z);
                gl.glVertex3d(seg.p0.x + offDir.x, seg.p0.y + offDir.y, seg.p0.z + offDir.z);
                gl.glVertex3d(seg.p1.x + offDir.x, seg.p1.y + offDir.y, seg.p1.z + offDir.z);
                gl.glVertex3d(seg.p2.x + offDir.x, seg.p2.y + offDir.y, seg.p2.z + offDir.z);
            }
            gl.glEnd();
            if (savedCullFaceEnabled[0] != 0) {
                gl.glEnable(GL2.GL_CULL_FACE);
            } else {
                gl.glDisable(GL2.GL_CULL_FACE);
            }
            gl.glCullFace(savedCullFaceMode[0]);
            if (shading == Shading.NONE) {
                renderer.setLightingEnabled(true);
            }
            gl.glShadeModel(savedShadeModel[0]);
        }
        gl.glPopMatrix();
    }
}

Output:
     GL2 gl = renderer.getGL2();
-    offsetMag = 1.0 * renderer.centerDistancePerPixel();
+    double offsetMag = 1.0 * renderer.centerDistancePerPixel();
     renderer.getZDirection();


Input:
public CommandResponse execute(GetAuthorizationUrlParams params) throws Exception {
    final Rp site = getRp();
    String authorizationEndpoint = getDiscoveryService().getConnectDiscoveryResponse(site).getAuthorizationEndpoint();
    List<String> scope = Lists.newArrayList();
    if (params.getScope() != null && !params.getScope().isEmpty()) {
        scope.addAll(params.getScope());
    } else if (site.getScope() != null) {
        scope.addAll(site.getScope());
    }
    authorizationEndpoint += "String_Node_Str" + Utils.joinAndUrlEncode(site.getResponseTypes());
    authorizationEndpoint += "String_Node_Str" + site.getClientId();
    authorizationEndpoint += "String_Node_Str" + site.getAuthorizationRedirectUri();
    authorizationEndpoint += "String_Node_Str" + Utils.joinAndUrlEncode(scope);
    authorizationEndpoint += "String_Node_Str" + getStateService().generateState();
    authorizationEndpoint += "String_Node_Str" + getStateService().generateNonce();
    String acrValues = Utils.joinAndUrlEncode(acrValues(site, params)).trim();
    if (!Strings.isNullOrEmpty(acrValues)) {
        authorizationEndpoint += "String_Node_Str" + acrValues;
    }
    if (!Strings.isNullOrEmpty(params.getPrompt())) {
        authorizationEndpoint += "String_Node_Str" + params.getPrompt();
    }
    if (!Strings.isNullOrEmpty(params.getHostedDomain())) {
        authorizationEndpoint += "String_Node_Str" + params.getHostedDomain();
    }
    if (params.getCustomParameters() != null && !params.getCustomParameters().isEmpty()) {
        authorizationEndpoint += "String_Node_Str" + AuthorizeRequestParam.CUSTOM_RESPONSE_HEADERS + "String_Node_Str" + Util.mapAsString(params.getCustomParameters());
    }
    return okResponse(new GetAuthorizationUrlResponse(authorizationEndpoint));
}

Output:
     if (params.getCustomParameters() != null && !params.getCustomParameters().isEmpty()) {
-        authorizationEndpoint += "String_Node_Str" + AuthorizeRequestParam.CUSTOM_RESPONSE_HEADERS + "String_Node_Str" + Util.mapAsString(params.getCustomParameters());
+        authorizationEndpoint += "String_Node_Str" + AuthorizeRequestParam.CUSTOM_RESPONSE_HEADERS + "String_Node_Str" + Utils.encode(Util.mapAsString(params.getCustomParameters()));
     }


Input:
private final void handleAppDiedLocked(ProcessRecord app, boolean restarting, boolean allowRestart) {
    int pid = app.pid;
    cleanUpApplicationRecordLocked(app, restarting, allowRestart, -1);
    if (!restarting) {
        removeLruProcessLocked(app);
        if (pid > 0) {
            ProcessList.remove(pid);
        }
    }
    if (mProfileProc == app) {
        clearProfilerLocked();
    }
    boolean hasVisibleActivities = mStackSupervisor.handleAppDiedLocked(app);
    app.activities.clear();
    if (app.instrumentationClass != null) {
        Slog.w(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + app.instrumentationClass);
        Bundle info = new Bundle();
        info.putString("String_Node_Str", "String_Node_Str");
        finishInstrumentationLocked(app, Activity.RESULT_CANCELED, info);
    }
    if (!restarting) {
        if (!mStackSupervisor.resumeTopActivitiesLocked()) {
            if (hasVisibleActivities) {
                mStackSupervisor.ensureActivitiesVisibleLocked(null, 0);
            }
        }
    }
}

Output:
     int pid = app.pid;
-    cleanUpApplicationRecordLocked(app, restarting, allowRestart, -1);
-    if (!restarting) {
+    boolean kept = cleanUpApplicationRecordLocked(app, restarting, allowRestart, -1);
+    if (!kept && !restarting) {
         removeLruProcessLocked(app);


Input:
public void testCoordinateJobArchiveLocationEnabledBaseLocationMissing() throws GenieException {
    final String clientHost = "String_Node_Str";
    final JobRequest jobRequest = new JobRequest.Builder(JOB_1_NAME, JOB_1_USER, JOB_1_VERSION, null, null, null).withDisableLogArchival(false).withId(JOB_1_ID).build();
    Mockito.when(this.jobPersistenceService.createJobRequest(Mockito.eq(jobRequest))).thenReturn(jobRequest);
    final ArgumentCaptor<Job> argument = ArgumentCaptor.forClass(Job.class);
    final JobCoordinatorService jobCoordinatorService = new JobCoordinatorServiceImpl(this.jobPersistenceService, this.jobSearchService, this.jobSubmitterService, null);
    jobCoordinatorService.coordinateJob(jobRequest, clientHost);
    Mockito.verify(this.jobPersistenceService).createJob(argument.capture());
    Assert.assertEquals(BASE_ARCHIVE_LOCATION + "String_Node_Str" + JOB_1_ID, argument.getValue().getArchiveLocation());
}

Output:
     final ArgumentCaptor<Job> argument = ArgumentCaptor.forClass(Job.class);
-    final JobCoordinatorService jobCoordinatorService = new JobCoordinatorServiceImpl(this.jobPersistenceService, this.jobSearchService, this.jobSubmitterService, null);
-    jobCoordinatorService.coordinateJob(jobRequest, clientHost);
+    final JobCoordinatorService jcs = new JobCoordinatorServiceImpl(this.jobPersistenceService, this.jobSearchService, this.jobSubmitterService, null);
+    jcs.coordinateJob(jobRequest, clientHost);
     Mockito.verify(this.jobPersistenceService).createJob(argument.capture());


Input:
public List<Mapreduce> getMapreducesByDataset(String account, String dataset) throws MetadataServiceException, TException {
    validateAccount(account);
    List<Mapreduce> mapreduces = getMapreduces(new Account(account));
    List<Mapreduce> queriesForDS = Lists.newLinkedList();
    for (Mapreduce mapreduce : mapreduces) {
        if (mapreduce.getDatasets().contains(dataset))
            queriesForDS.add(mapreduce);
    }
    return queriesForDS;
}

Output:
     for (Mapreduce mapreduce : mapreduces) {
-        if (mapreduce.getDatasets().contains(dataset))
+        if (mapreduce.getDatasets().contains(dataset)) {
             queriesForDS.add(mapreduce);


Input:
public Sound transform(Sound input) {
    Sound fs = input;
    UnivariateFunction function = this.getFunction(fs);
    return DownsampleSoundTransformation.buildSoundFromFunction(function, (int) fs.getTime()[fs.getTime().length - 1], input.getNbBytesPerFrame());
}

Output:
     UnivariateFunction function = this.getFunction(fs);
-    return DownsampleSoundTransformation.buildSoundFromFunction(function, (int) fs.getTime()[fs.getTime().length - 1], input.getNbBytesPerFrame());
+    return DownsampleSoundTransformation.buildSoundFromFunction(function, fs.getSamples().length, input.getNbBytesPerFrame());
 }


Input:
protected Object decode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
    RaopRtpPacket.Audio alacPacket = (RaopRtpPacket.Audio) msg;
    final byte[] alacBytes = new byte[alacPacket.getPayload().capacity() + 3];
    alacPacket.getPayload().getBytes(0, alacBytes, 0, alacPacket.getPayload().capacity());
    final int[] pcmSamples = new int[m_samplesPerFrame * 2];
    final int pcmSamplesBytes = AlacDecodeUtils.decode_frame(m_alacFile, alacBytes, pcmSamples, m_samplesPerFrame);
    final int pcmSamplesLength = pcmSamplesBytes / 4;
    Level level = Level.FINEST;
    if (s_logger.isLoggable(level))
        s_logger.log(level, "String_Node_Str" + alacBytes.length + "String_Node_Str" + pcmSamplesLength + "String_Node_Str");
    if (pcmSamplesLength != m_samplesPerFrame)
        throw new ProtocolException("String_Node_Str" + m_samplesPerFrame + "String_Node_Str" + pcmSamplesLength);
    RaopRtpPacket.Audio pcmPacket;
    if (alacPacket instanceof RaopRtpPacket.AudioTransmit) {
        pcmPacket = new RaopRtpPacket.AudioTransmit(pcmSamplesLength * 4);
        alacPacket.getBuffer().getBytes(0, pcmPacket.getBuffer(), 0, RaopRtpPacket.AudioTransmit.HeaderLength);
    } else if (alacPacket instanceof RaopRtpPacket.AudioRetransmit) {
        pcmPacket = new RaopRtpPacket.AudioRetransmit(pcmSamplesLength * 4);
        alacPacket.getBuffer().getBytes(0, pcmPacket.getBuffer(), 0, RaopRtpPacket.AudioRetransmit.HeaderLength);
    } else
        throw new ProtocolException("String_Node_Str" + alacPacket.getClass() + "String_Node_Str");
    for (int i = 0; i < pcmSamples.length; ++i) {
        int pcmSampleUnsigned = pcmSamples[i] + 0x8000;
        pcmPacket.getPayload().setByte(2 * i, (pcmSampleUnsigned & 0xff00) >> 8);
        pcmPacket.getPayload().setByte(2 * i + 1, pcmSampleUnsigned & 0x00ff);
    }
    return pcmPacket;
}

Output:
         pcmPacket = new RaopRtpPacket.AudioTransmit(pcmSamplesLength * 4);
-        alacPacket.getBuffer().getBytes(0, pcmPacket.getBuffer(), 0, RaopRtpPacket.AudioTransmit.HeaderLength);
+        alacPacket.getBuffer().getBytes(0, pcmPacket.getBuffer(), 0, RaopRtpPacket.AudioTransmit.Length);
     } else if (alacPacket instanceof RaopRtpPacket.AudioRetransmit) {


Input:
private void assertResolveNamesFails(String expectedError, String fileContent) {
    try {
        SoyFileSetParserBuilder.forFileContents(fileContent).declaredSyntaxVersion(SyntaxVersion.V2_0).typeRegistry(typeRegistry).parse();
        fail("String_Node_Str");
    } catch (SoySyntaxException e) {
        String message = e.getMessage();
        assertWithMessage("String_Node_Str" + message + "String_Node_Str" + expectedError + "String_Node_Str").that(message.contains(expectedError)).isTrue();
    }
}

Output:
 private void assertResolveNamesFails(String expectedError, String fileContent) {
-    try {
-        SoyFileSetParserBuilder.forFileContents(fileContent).declaredSyntaxVersion(SyntaxVersion.V2_0).typeRegistry(typeRegistry).parse();
-        fail("String_Node_Str");
-    } catch (SoySyntaxException e) {
-        String message = e.getMessage();
-        assertWithMessage("String_Node_Str" + message + "String_Node_Str" + expectedError + "String_Node_Str").that(message.contains(expectedError)).isTrue();
-    }
+    FormattingErrorReporter errorReporter = new FormattingErrorReporter();
+    SoyFileSetParserBuilder.forFileContents(fileContent).declaredSyntaxVersion(SyntaxVersion.V2_0).errorReporter(errorReporter).typeRegistry(typeRegistry).parse();
+    assertThat(errorReporter.getErrorMessages()).hasSize(1);
+    assertThat(errorReporter.getErrorMessages().get(0)).isEqualTo(expectedError);
 }


Input:
private boolean atomicWait() {
    waiting.incrementAndGet();
    try {
        synchronized (this) {
            try {
                wait();
            } catch (InterruptedException e) {
                return true;
            }
        }
    } finally {
        waiting.decrementAndGet();
    }
    return false;
}

Output:
     try {
-        synchronized (this) {
+        short blockId = blockIds.get(index);
+        boolean reserved = auxStore.isReserved(blockId);
+        synchronized (i) {
+            if (!reserved || !auxStore.testUnstable(blockId)) {
+                return false;
+            }
             try {


Input:
public int addMethod(MethodInfo method) {
    int methodId = method.getCodeAddress();
    if (isValidIndex(methodId) == false) {
        methodList.setSize(methodId + 1);
    }
    methodList.setElementAt(method, methodId);
    return methodId;
}

Output:
 public int addMethod(MethodInfo method) {
-    int methodId = method.getCodeAddress();
+    int methodId = getMethodId(method);
     if (isValidIndex(methodId) == false) {


Input:
public static Set<String> getAllClasspathJars(final String... excludeEnv) {
    final Set<String> jars = new HashSet<>();
    final Set<Path> excludePaths = new HashSet<>();
    for (final String env : excludeEnv) {
        final File file = new File(env);
        if (file.exists()) {
            excludePaths.add(file.toPath());
        }
    }
    for (final String path : System.getProperty("String_Node_Str").split(File.pathSeparator)) {
        try {
            final File file = new File(path);
            if (file.exists()) {
                final Path absolutePath = file.toPath();
                boolean toBeAdded = true;
                for (final Path prefix : excludePaths) {
                    if (absolutePath.startsWith(prefix)) {
                        toBeAdded = false;
                    }
                }
                if (toBeAdded) {
                    jars.add(absolutePath.toString());
                }
            }
        } catch (final InvalidPathException ex) {
            LOG.log(Level.FINE, "String_Node_Str", new Object[] { path, ex });
        }
    }
    return jars;
}

Output:
     for (final String env : excludeEnv) {
-        final File file = new File(env);
-        if (file.exists()) {
-            excludePaths.add(file.toPath());
+        final String path = System.getenv(env);
+        if (null != path) {
+            final File file = new File(path);
+            if (file.exists()) {
+                excludePaths.add(file.toPath());
+            }
         }


Input:
public KeyTracker.State onKeyTracker(int keyCode, KeyEvent event, KeyTracker.Stage stage, int duration) {
    WebView topWindow = getTopWindow();
    if (topWindow == null && mCustomView == null)
        return KeyTracker.State.NOT_TRACKING;
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (mCustomView != null) {
            mWebChromeClient.onHideCustomView();
            return KeyTracker.State.DONE_TRACKING;
        }
        if (stage == KeyTracker.Stage.LONG_REPEAT) {
            bookmarksOrHistoryPicker(true);
            return KeyTracker.State.DONE_TRACKING;
        } else if (stage == KeyTracker.Stage.UP) {
            WebView subwindow = mTabControl.getCurrentSubWindow();
            if (subwindow != null) {
                if (subwindow.canGoBack()) {
                    subwindow.goBack();
                } else {
                    dismissSubWindow(mTabControl.getCurrentTab());
                }
            } else {
                goBackOnePageOrQuit();
            }
            return KeyTracker.State.DONE_TRACKING;
        }
        return KeyTracker.State.KEEP_TRACKING;
    }
    return KeyTracker.State.NOT_TRACKING;
}

Output:
         if (stage == KeyTracker.Stage.LONG_REPEAT) {
-            bookmarksOrHistoryPicker(true);
+            bookmarksOrHistoryPicker(true, false);
             return KeyTracker.State.DONE_TRACKING;


Input:
public boolean isTriggerActive(TileEntity tile, EnumFacing side, IStatementContainer statementContainer, IStatementParameter[] parameters) {
    IFluidHandler handler = tile.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side.getOpposite());
    if (handler != null) {
        FluidStack searchedFluid = null;
        if (parameters != null && parameters.length >= 1 && parameters[0] != null && parameters[0].getItemStack() != null) {
            searchedFluid = FluidContainerRegistry.getFluidForFilledItem(parameters[0].getItemStack());
        }
        if (searchedFluid != null) {
            searchedFluid.amount = 1;
        }
        FluidTankInfo[] liquids = handler.getTankInfo(side);
        if (liquids == null || liquids.length == 0) {
            return false;
        }
        switch(state) {
            case Empty:
                for (FluidTankInfo c : liquids) {
                    if (c != null && c.fluid != null && c.fluid.amount > 0 && (searchedFluid == null || searchedFluid.isFluidEqual(c.fluid))) {
                        return false;
                    }
                }
                return true;
            case Contains:
                for (FluidTankInfo c : liquids) {
                    if (c != null && c.fluid != null && c.fluid.amount > 0 && (searchedFluid == null || searchedFluid.isFluidEqual(c.fluid))) {
                        return true;
                    }
                }
                return false;
            case Space:
                if (searchedFluid == null) {
                    for (FluidTankInfo c : liquids) {
                        if (c != null && (c.fluid == null || c.fluid.amount < c.capacity)) {
                            return true;
                        }
                    }
                    return false;
                }
                return handler.fill(side, searchedFluid, false) > 0;
            case Full:
                if (searchedFluid == null) {
                    for (FluidTankInfo c : liquids) {
                        if (c != null && (c.fluid == null || c.fluid.amount < c.capacity)) {
                            return false;
                        }
                    }
                    return true;
                }
                return handler.fill(side, searchedFluid, false) <= 0;
        }
    }
    return false;
}

Output:
         if (parameters != null && parameters.length >= 1 && parameters[0] != null && parameters[0].getItemStack() != null) {
-            searchedFluid = FluidContainerRegistry.getFluidForFilledItem(parameters[0].getItemStack());
+            searchedFluid = FluidUtil.getFluidContained(parameters[0].getItemStack());
         }


Input:
private SDOProperty getIDProp(Type aType) {
    return (SDOProperty) aType.getProperty((String) aType.get(SDOConstants.ID_PROPERTY));
}

Output:
 private SDOProperty getIDProp(Type aType) {
-    return (SDOProperty) aType.getProperty((String) aType.get(SDOConstants.ID_PROPERTY));
+    return (SDOProperty) aType.getProperty((String) ((SDOType) aType).get(SDOConstants.ID_PROPERTY));
 }


Input:
public GraphTextWriter getActionBytesAsHex(GraphTextWriter writer) {
    return Helper.byteArrayToHexWithHeader(writer, actionBytes);
}

Output:
 public GraphTextWriter getActionBytesAsHex(GraphTextWriter writer) {
-    return Helper.byteArrayToHexWithHeader(writer, actionBytes);
+    return Helper.byteArrayToHexWithHeader(writer, actionBytes.getRangeData());
 }


Input:
public static boolean isImplicit(String id) {
    return IMPLICIT_NAMES.contains(id);
}

Output:
 public static boolean isImplicit(String id) {
-    return IMPLICIT_NAMES.contains(id);
+    return "String_Node_Str".equals(id) || IMPLICIT_NAMES.contains(id);
 }


Input:
public void execute(CommandSender sender, String[] args) {
    MessagesConfig messages = Messages.getInstance();
    Player player = (Player) sender;
    User user = User.get(player);
    if (!user.hasGuild()) {
        player.sendMessage(messages.generalHasNoGuild);
        return;
    }
    if (!user.isOwner()) {
        player.sendMessage(messages.generalIsNotOwner);
        return;
    }
    Guild guild = user.getGuild();
    List<InvitationList.Invitation> invitations = InvitationList.getInvitationsFor(guild);
    if (args.length < 1) {
        if (invitations.size() == 0) {
            player.sendMessage(messages.allyHasNotInvitation);
            return;
        }
        List<String> list = messages.allyInvitationList;
        String guildNames = StringUtils.toString(InvitationList.getInvitationGuildNames(guild), false);
        for (String msg : list) {
            player.sendMessage(msg.replace("String_Node_Str", guildNames));
        }
        return;
    }
    String tag = args[0];
    if (!GuildUtils.tagExists(tag)) {
        player.sendMessage(StringUtils.replace(messages.generalGuildNotExists, "String_Node_Str", tag));
        return;
    }
    Guild invitedGuild = GuildUtils.byTag(tag);
    if (guild.equals(invitedGuild)) {
        player.sendMessage(messages.allySame);
        return;
    }
    if (guild.getAllies().contains(invitedGuild)) {
        player.sendMessage(messages.allyAlly);
        return;
    }
    if (InvitationList.hasInvitationFrom(guild, invitedGuild)) {
        if (!SimpleEventHandler.handle(new GuildAcceptAllyInvitationEvent(EventCause.USER, user, guild, invitedGuild))) {
            return;
        }
        InvitationList.expireInvitation(invitedGuild, guild);
        guild.addAlly(invitedGuild);
        invitedGuild.addAlly(guild);
        player.sendMessage(StringUtils.replace(messages.allyDone, "String_Node_Str", invitedGuild.getName()));
        Player owner = invitedGuild.getOwner().getPlayer();
        if (owner != null) {
            owner.sendMessage(messages.allyIDone.replace("String_Node_Str", guild.getName()));
        }
        for (User u : guild.getMembers()) {
            IndependentThread.action(ActionType.PREFIX_UPDATE_GUILD, u, invitedGuild);
        }
        for (User u : invitedGuild.getMembers()) {
            IndependentThread.action(ActionType.PREFIX_UPDATE_GUILD, u, guild);
        }
        return;
    }
    if (InvitationList.hasInvitationFrom(invitedGuild, guild)) {
        if (!SimpleEventHandler.handle(new GuildRevokeAllyInvitationEvent(EventCause.USER, user, guild, invitedGuild))) {
            return;
        }
        InvitationList.expireInvitation(guild, invitedGuild);
        player.sendMessage(messages.allyReturn.replace("String_Node_Str", invitedGuild.getName()));
        Player owner = invitedGuild.getOwner().getPlayer();
        if (owner != null) {
            owner.sendMessage(messages.allyIReturn.replace("String_Node_Str", guild.getName()));
        }
        return;
    }
    if (!SimpleEventHandler.handle(new GuildSendAllyInvitationEvent(EventCause.USER, user, guild, invitedGuild))) {
        return;
    }
    InvitationList.createInvitation(guild, invitedGuild);
    player.sendMessage(messages.allyInviteDone.replace("String_Node_Str", invitedGuild.getName()));
    Player owner = invitedGuild.getOwner().getPlayer();
    if (owner != null) {
        owner.sendMessage(messages.allyToInvited.replace("String_Node_Str", guild.getName()));
    }
}

Output:
     }
-    Guild invitedGuild = GuildUtils.byTag(tag);
+    Guild invitedGuild = GuildUtils.getByTag(tag);
     if (guild.equals(invitedGuild)) {


Input:
public void testSyslogUdp() {
    String data = UUID.randomUUID().toString();
    SyslogUdpSource syslogUdp = sources.syslogUdpSource().host(getContainerForStream().getHost());
    stream(syslogUdp + XD_DELIMETER + "String_Node_Str");
    waitForXD();
    syslogUdp.sendBytes((data + "String_Node_Str").getBytes());
    assertReceived(1);
    this.assertContains(data);
}

Output:
     String data = UUID.randomUUID().toString();
-    SyslogUdpSource syslogUdp = sources.syslogUdpSource().host(getContainerForStream().getHost());
+    SyslogUdpSource syslogUdp = sources.syslogUdpSource(getContainerForStream().getHost());
     stream(syslogUdp + XD_DELIMETER + "String_Node_Str");


Input:
private Integer getSizeThreshold(double riskThreshold) {
    double size = 1d / riskThreshold;
    double floor = Math.floor(size);
    if ((1d / floor) - (1d / size) >= 0.01d * riskThreshold) {
        floor += 1d;
    }
    return (int) floor;
}

Output:
     double floor = Math.floor(size);
-    if ((1d / floor) - (1d / size) >= 0.01d * riskThreshold) {
+    if ((1d / floor) - (1d / size) >= RELATIVE_THRESHOLD_PRECISION * riskThreshold) {
         floor += 1d;


Input:
public void onAnimationStarted() {
    if (!mStartAnimationTriggered) {
        BroadcastReceiver fallbackReceiver = new BroadcastReceiver() {
            public void onReceive(Context context, Intent intent) {
                if (getResultCode() == Activity.RESULT_OK) {
                    mStartAnimationTriggered = true;
                    return;
                }
                mHandler.postDelayed(new Runnable() {
                    public void run() {
                        onAnimationStarted();
                    }
                }, 75);
            }
        };
        Intent intent = new Intent(ACTION_START_ENTER_ANIMATION);
        intent.setPackage(mContext.getPackageName());
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
        mContext.sendOrderedBroadcastAsUser(intent, UserHandle.CURRENT, null, fallbackReceiver, null, Activity.RESULT_CANCELED, null, null);
    }
}

Output:
         intent.setPackage(mContext.getPackageName());
-        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
+        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT | Intent.FLAG_RECEIVER_FOREGROUND);
         mContext.sendOrderedBroadcastAsUser(intent, UserHandle.CURRENT, null, fallbackReceiver, null, Activity.RESULT_CANCELED, null, null);


Input:
final byte[][] generateMessage(Object name, int parameterCount, byte[] data, ObjectType interfaceClass, int AttributeOrdinal, Command cmd) {
    if (getLimits().getMaxInfoRX() == null) {
        throw new GXDLMSException("String_Node_Str");
    }
    java.nio.ByteBuffer buff;
    if (name instanceof byte[]) {
        buff = java.nio.ByteBuffer.wrap((byte[]) name);
    } else {
        if (name == null) {
            buff = java.nio.ByteBuffer.wrap(data);
        } else if (getUseLogicalNameReferencing()) {
            int len = data == null ? 0 : data.length;
            buff = java.nio.ByteBuffer.allocate(20 + len);
            if (cmd == Command.GetRequest || cmd == Command.SetRequest || cmd == Command.MethodRequest) {
                buff.putShort((short) interfaceClass.getValue());
                String[] items = ((String) name).split("String_Node_Str", -1);
                if (items.length != 6) {
                    throw new GXDLMSException("String_Node_Str");
                }
                for (String it : items) {
                    buff.put((byte) (Short.parseShort(it) & 0xFF));
                }
                buff.put((byte) AttributeOrdinal);
                buff.put((byte) 0x0);
            }
        } else {
            int len = data == null ? 0 : data.length;
            buff = java.nio.ByteBuffer.allocate(11 + len);
            if (name.getClass().isArray()) {
                for (int pos = 0; pos != Array.getLength(name); ++pos) {
                    Object it = Array.get(name, pos);
                    buff.put((byte) 2);
                    int base_address = ((Number) it).shortValue() & 0xFFFF;
                    base_address += ((AttributeOrdinal - 1) * 8);
                    buff.putShort((short) base_address);
                }
            } else {
                buff.put((byte) 1);
            }
            if (cmd == Command.ReadResponse || cmd == Command.WriteResponse) {
                buff.put((byte) 0x0);
            } else {
                buff.put((byte) parameterCount);
                int base_address = GXCommon.intValue(name);
                if (cmd == Command.MethodRequest) {
                    base_address += AttributeOrdinal;
                } else {
                    base_address += ((AttributeOrdinal - 1) * 8);
                }
                buff.putShort((short) base_address);
            }
        }
        if (data != null && data.length != 0) {
            buff.put(data);
        }
    }
    return splitToBlocks(buff, cmd);
}

Output:
                 buff.put((byte) AttributeOrdinal);
-                buff.put((byte) 0x0);
+                if (data == null || data.length == 0) {
+                    buff.put((byte) 0);
+                } else {
+                    buff.put((byte) 1);
+                }
             }


Input:
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);
    radius = Math.min(w, h) * 2;
    Drawable d = getDrawable();
    if (d != null) {
        if (d instanceof RoundedBitmapDrawable) {
            ((RoundedBitmapDrawable) d).setCornerRadius(radius);
            d.invalidateSelf();
        } else if (d instanceof TransitionDrawable) {
            Drawable d1 = ((TransitionDrawable) d).getDrawable(1);
            if (d1 instanceof RoundedBitmapDrawable) {
                ((RoundedBitmapDrawable) d1).setCornerRadius(radius);
                d.invalidateSelf();
            }
        }
    }
}

Output:
     super.onSizeChanged(w, h, oldw, oldh);
-    radius = Math.min(w, h) * 2;
+    radius = Math.max(w, h) * 2;
     Drawable d = getDrawable();


Input:
private void startSendService() {
    Intent i = new Intent(mContext, SyncService.class);
    i.putExtra("String_Node_Str", SyncService.STATUS_UPDATE);
    i.putExtra("String_Node_Str", type);
    i.putExtra("String_Node_Str", content);
    i.putExtra("String_Node_Str", photo);
    i.putExtra("String_Node_Str", mLocationString);
    i.putExtra("String_Node_Str", inReplyToStatusId);
    if (AppContext.DEBUG) {
        log("String_Node_Str" + i);
    }
    startService(i);
}

Output:
     i.putExtra("String_Node_Str", SyncService.STATUS_UPDATE);
-    i.putExtra("String_Node_Str", type);
-    i.putExtra("String_Node_Str", content);
-    i.putExtra("String_Node_Str", photo);
-    i.putExtra("String_Node_Str", mLocationString);
-    i.putExtra("String_Node_Str", inReplyToStatusId);
+    i.putExtra(StatusUpdateInfo.TAG, info);
     if (AppContext.DEBUG) {


Input:
public static boolean patternRule(IndicatorEnum indicatorType, TdColumn column) {
    int javaType = column.getJavaType();
    DataminingType dataminingType = MetadataHelper.getDataminingType(column);
    if (dataminingType == null) {
        dataminingType = MetadataHelper.getDefaultDataminingType(javaType);
    }
    switch(indicatorType) {
        case CountsIndicatorEnum:
        case RowCountIndicatorEnum:
            return true;
        case NullCountIndicatorEnum:
            return true;
        case DistinctCountIndicatorEnum:
        case UniqueIndicatorEnum:
        case DuplicateCountIndicatorEnum:
            return true;
        case BlankCountIndicatorEnum:
        case TextIndicatorEnum:
        case MinLengthIndicatorEnum:
        case MaxLengthIndicatorEnum:
        case AverageLengthIndicatorEnum:
            if (Java2SqlType.isTextInSQL(javaType)) {
                if (dataminingType == DataminingType.NOMINAL || dataminingType == DataminingType.UNSTRUCTURED_TEXT) {
                    return true;
                }
            }
            break;
        case ModeIndicatorEnum:
        case FrequencyIndicatorEnum:
            if (dataminingType == DataminingType.NOMINAL || dataminingType == DataminingType.INTERVAL) {
                return true;
            }
            break;
        case MeanIndicatorEnum:
        case MedianIndicatorEnum:
        case BoxIIndicatorEnum:
        case IQRIndicatorEnum:
        case LowerQuartileIndicatorEnum:
        case UpperQuartileIndicatorEnum:
        case RangeIndicatorEnum:
            if (Java2SqlType.isNumbericInSQL(javaType)) {
                if (dataminingType == DataminingType.INTERVAL) {
                    return true;
                }
            }
            break;
        case MinValueIndicatorEnum:
        case MaxValueIndicatorEnum:
            if (dataminingType == DataminingType.INTERVAL) {
                return true;
            }
            break;
        default:
            return false;
    }
    return false;
}

Output:
         case MaxValueIndicatorEnum:
-            if (dataminingType == DataminingType.INTERVAL) {
-                return true;
+            if (!Java2SqlType.isDateInSQL(javaType)) {
+                if (dataminingType == DataminingType.INTERVAL) {
+                    return true;
+                }
             }


Input:
static String escapeText(String input) {
    return escapeBytes(ByteString.copyFromUtf8(input));
}

Output:
 static String escapeText(String input) {
-    return escapeBytes(ByteString.copyFromUtf8(input));
+    StringBuilder builder = new StringBuilder(input.length());
+    CharacterIterator iter = new StringCharacterIterator(input);
+    for (char c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
+        switch(c) {
+            case '\b':
+                builder.append("String_Node_Str");
+                break;
+            case '\f':
+                builder.append("String_Node_Str");
+                break;
+            case '\n':
+                builder.append("String_Node_Str");
+                break;
+            case '\r':
+                builder.append("String_Node_Str");
+                break;
+            case '\t':
+                builder.append("String_Node_Str");
+                break;
+            case '\\':
+                builder.append("String_Node_Str");
+                break;
+            case '"':
+                builder.append("String_Node_Str");
+                break;
+            default:
+                if (c >= 0x0000 && c <= 0x001F) {
+                    appendEscapedUnicode(builder, c);
+                } else if (Character.isHighSurrogate(c)) {
+                    appendEscapedUnicode(builder, c);
+                    c = iter.next();
+                    if (c == CharacterIterator.DONE)
+                        throw new IllegalArgumentException("String_Node_Str");
+                    appendEscapedUnicode(builder, c);
+                } else {
+                    builder.append(c);
+                }
+                break;
+        }
+    }
+    return builder.toString();
 }


Input:
public static void tracePolyhedron(Batcher b, Polyhedron polyhedron, Vector3 position, Color color) {
    b.begin(Primitive.LINE_STRIP);
    {
        for (Vector3 vertex : polyhedron.getVertices()) {
            b.vertex(vertex.add(polyhedron.getPosition().add(position)));
            b.color(color);
        }
    }
    b.end();
}

Output:
     {
-        for (Vector3 vertex : polyhedron.getVertices()) {
-            b.vertex(vertex.add(polyhedron.getPosition().add(position)));
+        Vector3 v1;
+        Vector3 v2;
+        Vector3 v3;
+        for (int v = 0; v < polyhedron.vertexCount() - 2; v++) {
+            if ((v & 1) != 0) {
+                v1 = polyhedron.getVertex(v);
+                v2 = polyhedron.getVertex(v + 1);
+                v3 = polyhedron.getVertex(v + 2);
+            } else {
+                v1 = polyhedron.getVertex(v);
+                v2 = polyhedron.getVertex(v + 2);
+                v3 = polyhedron.getVertex(v + 1);
+            }
+            v1 = v1.add(polyhedron.getPosition()).add(position);
+            v2 = v2.add(polyhedron.getPosition()).add(position);
+            v3 = v3.add(polyhedron.getPosition()).add(position);
+            b.vertex(v1);
+            b.color(color);
+            b.vertex(v2);
+            b.color(color);
+            b.vertex(v3);
             b.color(color);


Input:
private static String elements(OAuthRequest request, OAuthParameters params) throws OAuthSignatureException {
    StringBuffer buf = new StringBuffer(URLCodec.encode(request.getRequestMethod().toUpperCase()));
    buf.append('&').append(URLCodec.encode(constructRequestURL(request)));
    buf.append('&').append(URLCodec.encode(normalizeParameters(request, params)));
    return buf.toString();
}

Output:
 private static String elements(OAuthRequest request, OAuthParameters params) throws OAuthSignatureException {
-    StringBuffer buf = new StringBuffer(URLCodec.encode(request.getRequestMethod().toUpperCase()));
-    buf.append('&').append(URLCodec.encode(constructRequestURL(request)));
-    buf.append('&').append(URLCodec.encode(normalizeParameters(request, params)));
+    StringBuffer buf = new StringBuffer(request.getRequestMethod().toUpperCase());
+    URI uri = constructRequestURL(request);
+    String tp = uri.getScheme();
+    buf.append('&').append(UriComponent.encode(tp, UriComponent.Type.SCHEME));
+    tp = uri.getAuthority();
+    buf.append("String_Node_Str").append(UriComponent.encode(tp, UriComponent.Type.AUTHORITY));
+    tp = uri.getPath();
+    buf.append(UriComponent.encode(tp, UriComponent.Type.PATH_SEGMENT));
+    buf.append('&').append(UriComponent.encode(normalizeParameters(request, params), UriComponent.Type.QUERY_PARAM));
+    System.err.println("String_Node_Str" + buf);
     return buf.toString();


Input:
public void run() {
    if (player.isDead()) {
        burningPlayers.remove(player);
        this.cancel();
    } else if (player.getLocation().getBlock().isLiquid() && player.getLocation().getWorld().getName().equalsIgnoreCase(Settings.worldName)) {
        if (!Settings.acidDamageType.isEmpty()) {
            for (PotionEffectType t : Settings.acidDamageType) {
                if (t.equals(PotionEffectType.BLINDNESS) || t.equals(PotionEffectType.CONFUSION) || t.equals(PotionEffectType.HUNGER) || t.equals(PotionEffectType.SLOW) || t.equals(PotionEffectType.SLOW_DIGGING) || t.equals(PotionEffectType.WEAKNESS)) {
                    player.addPotionEffect(new PotionEffect(t, 600, 1));
                } else {
                    player.addPotionEffect(new PotionEffect(t, 200, 1));
                }
            }
        }
        if (Settings.acidDamage > 0D) {
            double health = player.getHealth() - (Settings.acidDamage - Settings.acidDamage * getDamageReduced(player));
            if (health < 0D) {
                health = 0D;
            } else if (health > 20D) {
                health = 20D;
            }
            player.setHealth(health);
            player.getWorld().playSound(playerLoc, Sound.FIZZ, 2F, 2F);
        }
    } else {
        burningPlayers.remove(player);
        this.cancel();
    }
}

Output:
         this.cancel();
-    } else if (player.getLocation().getBlock().isLiquid() && player.getLocation().getWorld().getName().equalsIgnoreCase(Settings.worldName)) {
+    } else if ((player.getLocation().getBlock().isLiquid() || player.getLocation().getBlock().getRelative(BlockFace.UP).isLiquid()) && player.getLocation().getWorld().getName().equalsIgnoreCase(Settings.worldName)) {
         if (!Settings.acidDamageType.isEmpty()) {


Input:
public void activateTheme(String themeId) {
    if (!mSite.isUsingWpComRestApi()) {
        AppLog.i(T.THEMES, "String_Node_Str");
        return;
    }
    ThemeModel theme = mThemeStore.getInstalledThemeByThemeId(mSite, themeId);
    if (theme == null) {
        theme = mThemeStore.getWpComThemeByThemeId(themeId);
        if (theme == null) {
            AppLog.w(T.THEMES, "String_Node_Str");
            return;
        }
        if (mSite.isJetpackConnected()) {
            mDispatcher.dispatch(ThemeActionBuilder.newInstallThemeAction(new ActivateThemePayload(mSite, theme)));
            return;
        }
    }
    mDispatcher.dispatch(ThemeActionBuilder.newActivateThemeAction(new ActivateThemePayload(mSite, theme)));
}

Output:
         if (mSite.isJetpackConnected()) {
-            mDispatcher.dispatch(ThemeActionBuilder.newInstallThemeAction(new ActivateThemePayload(mSite, theme)));
+            mDispatcher.dispatch(ThemeActionBuilder.newInstallThemeAction(new SiteThemePayload(mSite, theme)));
             return;


Input:
public synchronized void send(final EvaluatorRuntimeProtocol.EvaluatorControlProto evaluatorControlProto) {
    if (!this.wrapped.isPresent()) {
        throw new IllegalStateException("String_Node_Str");
    }
    if (!this.stateManager.isRunning()) {
        final String msg = new StringBuilder().append("String_Node_Str").append(this.evaluatorId).append("String_Node_Str").append(this.stateManager.toString()).append("String_Node_Str").append(evaluatorControlProto.toString()).toString();
        throw new IllegalStateException(msg);
    }
    this.wrapped.get().onNext(evaluatorControlProto);
}

Output:
     if (!this.stateManager.isRunning()) {
-        final String msg = new StringBuilder().append("String_Node_Str").append(this.evaluatorId).append("String_Node_Str").append(this.stateManager.toString()).append("String_Node_Str").append(evaluatorControlProto.toString()).toString();
-        throw new IllegalStateException(msg);
+        LOG.log(Level.WARNING, "String_Node_Str", new Object[] { this.evaluatorId, this.stateManager, evaluatorControlProto });
+        return;
     }


Input:
public float getScore(Data feature) {
    Float score = scoreCache.get(feature);
    if (score == null) {
        score = calculateScore(feature);
        scoreCache.putIfAbsent(feature, score);
    }
    return score;
}

Output:
 public float getScore(Data feature) {
-    Float score = scoreCache.get(feature);
-    if (score == null) {
-        score = calculateScore(feature);
-        scoreCache.putIfAbsent(feature, score);
+    ScoreCache cached = scoreCache;
+    if (feature != cached.feature) {
+        cached = new ScoreCache(feature, calculateScore(feature));
+        scoreCache = cached;
     }


Input:
void runTest(final GraphContext graphContext, final String inputPath, final List<Path> userRulesDirs, final boolean sourceMode, final List<String> includePackages, final List<String> excludePackages) throws Exception {
    WindupConfiguration wpc = new WindupConfiguration().setGraphContext(graphContext);
    wpc.setInputPath(Paths.get(inputPath));
    wpc.setOutputDirectory(graphContext.getGraphDirectory());
    if (userRulesDirs != null) {
        wpc.setUserRulesDirectories(userRulesDirs);
    }
    wpc.setOptionValue(SourceModeOption.NAME, sourceMode);
    wpc.setOptionValue(ScanPackagesOption.NAME, includePackages);
    wpc.setOptionValue(ExcludePackagesOption.NAME, excludePackages);
    RecordingWindupProgressMonitor progressMonitor = new RecordingWindupProgressMonitor();
    wpc.setProgressMonitor(progressMonitor);
    processor.execute(wpc);
    Assert.assertFalse(progressMonitor.isCancelled());
    Assert.assertTrue(progressMonitor.isDone());
    Assert.assertFalse(progressMonitor.getSubTaskNames().isEmpty());
    Assert.assertTrue(progressMonitor.getTotalWork() > 0);
    Assert.assertTrue(progressMonitor.getCompletedWork() > 0);
    Assert.assertEquals(progressMonitor.getTotalWork(), progressMonitor.getCompletedWork());
}

Output:
     wpc.setOutputDirectory(graphContext.getGraphDirectory());
-    if (userRulesDirs != null) {
-        wpc.setUserRulesDirectories(userRulesDirs);
+    if (userRulesDir != null) {
+        wpc.setOptionValue(UserRulesDirectoryOption.NAME, userRulesDir);
     }


Input:
public void loadSettings(final Locale locale, final InputAttributes inputAttributes) {
    final SharedPreferences prefs = mPrefs;
    final RunInLocale<SettingsValues> job = new RunInLocale<SettingsValues>() {

        protected SettingsValues job(final Resources res) {
            return new SettingsValues(prefs, locale, res, inputAttributes);
        }
    };
    mSettingsValues = job.runInLocale(mRes, locale);
}

Output:
 public void loadSettings(final Locale locale, final InputAttributes inputAttributes) {
-    final SharedPreferences prefs = mPrefs;
-    final RunInLocale<SettingsValues> job = new RunInLocale<SettingsValues>() {
+    mSettingsValuesLock.lock();
+    try {
+        final SharedPreferences prefs = mPrefs;
+        final RunInLocale<SettingsValues> job = new RunInLocale<SettingsValues>() {


Input:
private XSDSimpleTypeDefinition getCurSelectedBuildInBaseType() {
    IStructuredSelection selection = (IStructuredSelection) comboBuildInTypes.getSelection();
    if (selection == null || selection.isEmpty())
        return null;
    return (XSDSimpleTypeDefinition) selection.getFirstElement();
}

Output:
     IStructuredSelection selection = (IStructuredSelection) comboBuildInTypes.getSelection();
-    if (selection == null || selection.isEmpty())
+    if (selection == null || selection.isEmpty()) {
         return null;


Input:
public List<MeaningSpan> performD2KBTask(Document document) throws GerbilException {
    return getDocumentMarkings(document.getDocumentURI(), MeaningSpan.class);
}

Output:
 public List<MeaningSpan> performD2KBTask(Document document) throws GerbilException {
-    return getDocumentMarkings(document.getDocumentURI(), MeaningSpan.class);
+    return getDocumentMarkings(document.getDocumentURI(), document.getText().length(), MeaningSpan.class);
 }


Input:
public List getAllThemes() {
    List elementList = module.getModuleNameSpace(Module.THEME_NAME_SPACE).getElements(IModuleNameSpace.ONE_LEVEL);
    return generateHandleList(elementList);
}

Output:
 public List getAllThemes() {
-    List elementList = module.getModuleNameSpace(Module.THEME_NAME_SPACE).getElements(IModuleNameSpace.ONE_LEVEL);
+    List elementList = module.getModuleNameSpace(Module.THEME_NAME_SPACE).getElements(IModuleNameSpace.DIRECTLY_INCLUDED_LEVEL);
     return generateHandleList(elementList);


Input:
public synchronized void updateMap() {
    super.updateMap();
    data = new int[size];
    for (int cell = 0; cell < data.length; cell++) {
        if (!Dungeon.level.discoverable[cell] || !Dungeon.level.insideMap(cell)) {
            data[cell] = CLEARED;
        } else {
            updateMapCell(cell);
        }
    }
}

Output:
     for (int cell = 0; cell < data.length; cell++) {
-        if (!Dungeon.level.discoverable[cell] || !Dungeon.level.insideMap(cell)) {
+        if (!Dungeon.level.discoverable[cell] || (cell - mapWidth) <= 0 || (cell + mapWidth) >= size) {
             data[cell] = CLEARED;