Input:
public void testReadWriteOverride() {
    int[] availableFormats = new int[] { 0x20, 0x32315659, 0x11, 0x100, 0x22, 0x23 };
    int[] expectedIntValues = new int[] { 0x20, 0x32315659, 0x11, 0x21, 0x22, 0x23 };
    int availableFormatTag = CameraMetadataNative.getTag("String_Node_Str");
    mMetadata.set(CameraCharacteristics.SCALER_AVAILABLE_FORMATS, availableFormats);
    byte[] availableFormatValues = mMetadata.readValues(availableFormatTag);
    ByteBuffer bf = ByteBuffer.wrap(availableFormatValues).order(ByteOrder.nativeOrder());
    assertEquals(expectedIntValues.length * 4, availableFormatValues.length);
    for (int i = 0; i < expectedIntValues.length; ++i) {
        assertEquals(expectedIntValues[i], bf.getInt());
    }
    byte[] availableFormatsAsByteArray = new byte[expectedIntValues.length * 4];
    ByteBuffer availableFormatsByteBuffer = ByteBuffer.wrap(availableFormatsAsByteArray).order(ByteOrder.nativeOrder());
    for (int value : expectedIntValues) {
        availableFormatsByteBuffer.putInt(value);
    }
    mMetadata.writeValues(availableFormatTag, availableFormatsAsByteArray);
    int[] resultFormats = mMetadata.get(CameraCharacteristics.SCALER_AVAILABLE_FORMATS);
    assertNotNull("String_Node_Str", resultFormats);
    assertArrayEquals(availableFormats, resultFormats);
    int[] expectedFaceIds = new int[] { 1, 2, 3, 4, 5 };
    byte[] expectedFaceScores = new byte[] { 10, 20, 30, 40, 50 };
    int numFaces = expectedFaceIds.length;
    Rect[] expectedRects = new Rect[numFaces];
    for (int i = 0; i < numFaces; i++) {
        expectedRects[i] = new Rect(i * 4 + 1, i * 4 + 2, i * 4 + 3, i * 4 + 4);
    }
    int[] expectedFaceLM = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 };
    Point[] expectedFaceLMPoints = new Point[numFaces * 3];
    for (int i = 0; i < numFaces; i++) {
        expectedFaceLMPoints[i * 3] = new Point(expectedFaceLM[i * 6], expectedFaceLM[i * 6 + 1]);
        expectedFaceLMPoints[i * 3 + 1] = new Point(expectedFaceLM[i * 6 + 2], expectedFaceLM[i * 6 + 3]);
        expectedFaceLMPoints[i * 3 + 2] = new Point(expectedFaceLM[i * 6 + 4], expectedFaceLM[i * 6 + 5]);
    }
    mMetadata.set(CaptureResult.STATISTICS_FACE_DETECT_MODE, CaptureResult.STATISTICS_FACE_DETECT_MODE_FULL);
    mMetadata.set(CaptureResult.STATISTICS_FACE_IDS, expectedFaceIds);
    mMetadata.set(CaptureResult.STATISTICS_FACE_SCORES, expectedFaceScores);
    mMetadata.set(CaptureResult.STATISTICS_FACE_RECTANGLES, expectedRects);
    mMetadata.set(CaptureResult.STATISTICS_FACE_LANDMARKS, expectedFaceLM);
    Face[] resultFaces = mMetadata.get(CaptureResult.STATISTICS_FACES);
    assertEquals(numFaces, resultFaces.length);
    for (int i = 0; i < numFaces; i++) {
        assertEquals(expectedFaceIds[i], resultFaces[i].getId());
        assertEquals(expectedFaceScores[i], resultFaces[i].getScore());
        assertEquals(expectedRects[i], resultFaces[i].getBounds());
        assertEquals(expectedFaceLMPoints[i * 3], resultFaces[i].getLeftEyePosition());
        assertEquals(expectedFaceLMPoints[i * 3 + 1], resultFaces[i].getRightEyePosition());
        assertEquals(expectedFaceLMPoints[i * 3 + 2], resultFaces[i].getMouthPosition());
    }
    mMetadata.set(CaptureResult.STATISTICS_FACE_DETECT_MODE, CaptureResult.STATISTICS_FACE_DETECT_MODE_SIMPLE);
    mMetadata.set(CaptureResult.STATISTICS_FACE_SCORES, expectedFaceScores);
    mMetadata.set(CaptureResult.STATISTICS_FACE_RECTANGLES, expectedRects);
    Face[] resultSimpleFaces = mMetadata.get(CaptureResult.STATISTICS_FACES);
    assertEquals(numFaces, resultSimpleFaces.length);
    for (int i = 0; i < numFaces; i++) {
        assertEquals(Face.ID_UNSUPPORTED, resultSimpleFaces[i].getId());
        assertEquals(expectedFaceScores[i], resultSimpleFaces[i].getScore());
        assertEquals(expectedRects[i], resultSimpleFaces[i].getBounds());
        assertNull(resultSimpleFaces[i].getLeftEyePosition());
        assertNull(resultSimpleFaces[i].getRightEyePosition());
        assertNull(resultSimpleFaces[i].getMouthPosition());
    }
}

Output:
     int availableFormatTag = CameraMetadataNative.getTag("String_Node_Str");
-    mMetadata.set(CameraCharacteristics.SCALER_AVAILABLE_FORMATS, availableFormats);
-    byte[] availableFormatValues = mMetadata.readValues(availableFormatTag);
-    ByteBuffer bf = ByteBuffer.wrap(availableFormatValues).order(ByteOrder.nativeOrder());
-    assertEquals(expectedIntValues.length * 4, availableFormatValues.length);
-    for (int i = 0; i < expectedIntValues.length; ++i) {
-        assertEquals(expectedIntValues[i], bf.getInt());
-    }
-    byte[] availableFormatsAsByteArray = new byte[expectedIntValues.length * 4];
-    ByteBuffer availableFormatsByteBuffer = ByteBuffer.wrap(availableFormatsAsByteArray).order(ByteOrder.nativeOrder());
-    for (int value : expectedIntValues) {
-        availableFormatsByteBuffer.putInt(value);
-    }
-    mMetadata.writeValues(availableFormatTag, availableFormatsAsByteArray);
-    int[] resultFormats = mMetadata.get(CameraCharacteristics.SCALER_AVAILABLE_FORMATS);
-    assertNotNull("String_Node_Str", resultFormats);
-    assertArrayEquals(availableFormats, resultFormats);
+    Key<int[]> formatKey = CameraCharacteristics.SCALER_AVAILABLE_FORMATS;
+    validateArrayMetadataReadWriteOverride(formatKey, availableFormats, expectedIntValues, availableFormatTag);
+    final int OUTPUT = CameraCharacteristics.SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT;
+    int[] availableStreamConfigs = new int[] { 0x20, 3280, 2464, OUTPUT, 0x23, 3264, 2448, OUTPUT, 0x23, 3200, 2400, OUTPUT, 0x100, 3264, 2448, OUTPUT, 0x100, 3200, 2400, OUTPUT, 0x100, 2592, 1944, OUTPUT, 0x100, 2048, 1536, OUTPUT, 0x100, 1920, 1080, OUTPUT };
+    int[] expectedAvailableStreamConfigs = new int[] { 0x20, 3280, 2464, OUTPUT, 0x23, 3264, 2448, OUTPUT, 0x23, 3200, 2400, OUTPUT, 0x21, 3264, 2448, OUTPUT, 0x21, 3200, 2400, OUTPUT, 0x21, 2592, 1944, OUTPUT, 0x21, 2048, 1536, OUTPUT, 0x21, 1920, 1080, OUTPUT };
+    int availableStreamConfigTag = CameraMetadataNative.getTag("String_Node_Str");
+    Key<int[]> configKey = CameraCharacteristics.SCALER_AVAILABLE_STREAM_CONFIGURATIONS;
+    validateArrayMetadataReadWriteOverride(configKey, availableStreamConfigs, expectedAvailableStreamConfigs, availableStreamConfigTag);
+    long[] availableMinDurations = new long[] { 0x20, 3280, 2464, 33333336, 0x23, 3264, 2448, 33333336, 0x23, 3200, 2400, 33333336, 0x100, 3264, 2448, 33333336, 0x100, 3200, 2400, 33333336, 0x100, 2592, 1944, 33333336, 0x100, 2048, 1536, 33333336, 0x100, 1920, 1080, 33333336 };
+    long[] expectedAvailableMinDurations = new long[] { 0x20, 3280, 2464, 33333336, 0x23, 3264, 2448, 33333336, 0x23, 3200, 2400, 33333336, 0x21, 3264, 2448, 33333336, 0x21, 3200, 2400, 33333336, 0x21, 2592, 1944, 33333336, 0x21, 2048, 1536, 33333336, 0x21, 1920, 1080, 33333336 };
+    int availableMinDurationsTag = CameraMetadataNative.getTag("String_Node_Str");
+    Key<long[]> durationKey = CameraCharacteristics.SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
+    validateArrayMetadataReadWriteOverride(durationKey, availableMinDurations, expectedAvailableMinDurations, availableMinDurationsTag);
     int[] expectedFaceIds = new int[] { 1, 2, 3, 4, 5 };


Input:
public IStatus runInUIThread(IProgressMonitor monitor) {
    try {
        Cursor wait = new Cursor(getViewSite().getShell().getDisplay(), SWT.CURSOR_WAIT);
        viewer.getControl().setCursor(wait);
        new ServerRefreshAction(view, serverRoot).run();
        viewer.expandToLevel(serverRoot, 1);
        viewer.getControl().setCursor(new Cursor(getViewSite().getShell().getDisplay(), SWT.CURSOR_ARROW));
        return Status.OK_STATUS;
    } catch (Exception e) {
        e.printStackTrace();
        return Status.CANCEL_STATUS;
    }
}

Output:
         viewer.getControl().setCursor(wait);
-        new ServerRefreshAction(view, serverRoot).run();
+        new ServerRefreshAction(view, serverRoot).doRun();
         viewer.expandToLevel(serverRoot, 1);


Input:
protected boolean filterEntry(IRow row) {
    if (filterInferredPercentage >= 1)
        return super.filterEntry(row);
    if (!super.filterEntry(row))
        return false;
    boolean[] inferreds = isValueInferreds(row);
    boolean any = false;
    for (int i = 0; i < inferreds.length; ++i) {
        if (inferreds[i]) {
            any = true;
        }
    }
    if (!any)
        return true;
    float[] ws = getWeights();
    float inferPercentage = 0;
    for (int i = 0; i < inferreds.length; ++i) {
        if (inferreds[i])
            inferPercentage += ws[i];
    }
    return inferPercentage < filterInferredPercentage;
}

Output:
         return super.filterEntry(row);
-    if (!super.filterEntry(row))
+    if (!super.filterEntry(row)) {
         return false;


Input:
private boolean compareMinMax() {
    if (maxVersion == null || maxVersion.trim().equals("String_Node_Str") || minVersion == null || minVersion.trim().equals("String_Node_Str")) {
        return true;
    }
    String[] maxSplit = maxVersion.split("String_Node_Str");
    String[] minSplit = minVersion.split("String_Node_Str");
    for (int i = 0; i < 3; i++) {
        try {
            if (Integer.parseInt(maxSplit[i]) - Integer.parseInt(minSplit[i]) < 0) {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }
    return true;
}

Output:
     }
-    String[] maxSplit = maxVersion.split("String_Node_Str");
-    String[] minSplit = minVersion.split("String_Node_Str");
-    for (int i = 0; i < 3; i++) {
-        try {
-            if (Integer.parseInt(maxSplit[i]) - Integer.parseInt(minSplit[i]) < 0) {
-                return false;
-            }
-        } catch (Exception e) {
+    try {
+        Version minV = Version.parseVersion(minVersion);
+        Version maxV = Version.parseVersion(maxVersion);
+        if (minV == null && maxV == null) {
             return false;


Input:
public void onChatMessage(MessageChannelEvent.Chat event, Player player) {
    Optional<Faction> optionalPlayerFaction = FactionLogic.getFactionByPlayerUUID(player.getUniqueId());
    if (optionalPlayerFaction.isPresent()) {
        MessageChannel messageChannel = event.getOriginalChannel();
        Faction playerFaction = optionalPlayerFaction.get();
        Text.Builder formattedMessage = Text.builder();
        Text.Builder factionAndRankPrefix = Text.builder();
        Text.Builder otherPrefixesAndPlayer = Text.builder();
        Text.Builder message = Text.builder();
        otherPrefixesAndPlayer.append(event.getMessage().getChildren().get(0));
        if (EagleFactions.ChatList.containsKey(player.getUniqueId())) {
            Text.Builder chatTypePrefix = Text.builder();
            if (EagleFactions.ChatList.get(player.getUniqueId()).equals(ChatEnum.Alliance)) {
                message.append(Text.of(TextColors.BLUE, event.getRawMessage()));
                chatTypePrefix.append(getAlliancePrefix());
                messageChannel.asMutable().clearMembers();
                Set<MessageReceiver> receivers = new HashSet<>();
                for (String allianceName : playerFaction.Alliances) {
                    receivers.addAll(FactionLogic.getOnlinePlayers(FactionLogic.getFactionByName(allianceName)));
                }
                receivers.addAll(FactionLogic.getOnlinePlayers(playerFaction));
                messageChannel = MessageChannel.fixed(receivers);
            } else if (EagleFactions.ChatList.get(player.getUniqueId()).equals(ChatEnum.Faction)) {
                message.append(Text.of(TextColors.GREEN, event.getRawMessage()));
                chatTypePrefix.append(getFactionPrefix());
                messageChannel.asMutable().clearMembers();
                Set<MessageReceiver> receivers = new HashSet<>();
                receivers.addAll(FactionLogic.getOnlinePlayers(playerFaction));
                messageChannel = MessageChannel.fixed(receivers);
            }
            formattedMessage.append(chatTypePrefix.build());
        } else {
            message.append(event.getMessage().getChildren().get(1));
        }
        if (MainLogic.getPrefixOption().equals("String_Node_Str")) {
            if (!playerFaction.Tag.toPlainSingle().equals("String_Node_Str")) {
                if (MainLogic.areColoredTagsAllowed()) {
                    Text factionTag = Text.builder().append(MainLogic.getFactionPrefixStart(), playerFaction.Tag, MainLogic.getFactionPrefixEnd()).build();
                    factionAndRankPrefix.append(factionTag);
                } else {
                    Text factionTag = Text.builder().append(MainLogic.getFactionPrefixStart(), Text.of(TextColors.GREEN, playerFaction.Tag), MainLogic.getFactionPrefixEnd()).build();
                    factionAndRankPrefix.append(factionTag);
                }
            }
        } else if (MainLogic.getPrefixOption().equals("String_Node_Str")) {
            Text factionNamePrefix = Text.builder().append(MainLogic.getFactionPrefixStart(), Text.of(TextColors.GREEN, playerFaction.Name, TextColors.RESET), MainLogic.getFactionPrefixEnd()).build();
            factionAndRankPrefix.append(factionNamePrefix);
        }
        if (MainLogic.shouldDisplayRank()) {
            if (playerFaction.Leader.equals(player.getUniqueId().toString())) {
                Text leaderPrefix = Text.builder().append(Text.of("String_Node_Str", TextColors.GOLD, "String_Node_Str", TextColors.RESET, "String_Node_Str")).build();
                factionAndRankPrefix.append(leaderPrefix);
            }
            if (playerFaction.Officers.contains(player.getUniqueId().toString())) {
                Text officerPrefix = Text.builder().append(Text.of("String_Node_Str", TextColors.GOLD, "String_Node_Str", TextColors.RESET, "String_Node_Str")).build();
                factionAndRankPrefix.append(officerPrefix);
            }
        }
        formattedMessage.append(factionAndRankPrefix.build());
        formattedMessage.append(otherPrefixesAndPlayer.build());
        formattedMessage.append(message.build());
        Text messageToPrint = Text.builder().append(formattedMessage.build()).build();
        event.setChannel(messageChannel);
        event.setMessage(messageToPrint);
    }
    return;
}

Output:
                     Text factionTag = Text.builder().append(MainLogic.getFactionPrefixStart(), playerFaction.Tag, MainLogic.getFactionPrefixEnd()).build();
-                    factionAndRankPrefix.append(factionTag);
+                    factionPrefixText.append(factionTag);
                 } else {


Input:
private void player(Player caller, String[] cmd) {
    if (cmd.length < 2) {
        caller.notice(Translator.translateAndFormat("String_Node_Str", "String_Node_Str"));
        return;
    }
    Player p = Canary.getServer().matchPlayer(cmd[1]);
    if (p == null) {
        caller.notice(Translator.translate("String_Node_Str") + "String_Node_Str" + Translator.translateAndFormat("String_Node_Str", cmd[1]));
        return;
    }
    Ban ban = new Ban();
    String reason = "String_Node_Str";
    long timestamp = -1L;
    if (cmd.length >= 3) {
        try {
            timestamp = Canary.parseTime(Long.parseLong(cmd[cmd.length - 2]), cmd[cmd.length - 1]);
            reason = StringUtils.joinString(cmd, "String_Node_Str", 2, cmd.length - 2);
        } catch (NumberFormatException e) {
            reason = StringUtils.joinString(cmd, "String_Node_Str", 2);
            timestamp = -1L;
        }
    }
    ban.setReason(reason);
    ban.setTimestamp(timestamp);
    ban.setBanningPlayer(caller.getName());
    ban.setSubject(p.getName());
    ban.setIp(p.getIP());
    ban.setIsIpBan(true);
    Canary.bans().issueBan(ban);
    Canary.hooks().callHook(new BanHook(p, p.getIP(), caller, reason, timestamp));
    caller.notice(Translator.translateAndFormat("String_Node_Str", cmd[1]));
    p.kick(reason);
}

Output:
     if (cmd.length < 2) {
-        caller.notice(Translator.translateAndFormat("String_Node_Str", "String_Node_Str"));
+        Canary.help().getHelp(caller, "String_Node_Str");
         return;


Input:
void drawOut(Graphics2D g, int ctr, int w) {
    int[] ptx = new int[7];
    int[] pty = new int[7];
    int left = ctr - w / 2;
    int right = ctr + w / 2;
    int top = cy - height / 2;
    int bottom = cy + height / 2;
    ptx[0] = right;
    pty[0] = top;
    ptx[1] = right;
    pty[1] = top + 6;
    ptx[2] = right;
    pty[2] = bottom - 6;
    ptx[3] = right;
    pty[3] = bottom;
    ptx[4] = left + 10;
    pty[4] = bottom;
    ptx[5] = left;
    pty[5] = cy;
    ptx[6] = left + 10;
    pty[6] = top;
    g.setColor(Color.BLACK);
    g.drawPolygon(ptx, pty, 7);
    if (this == driver.selBlock)
        g.setColor(new Color(255, 255, 200));
    else
        g.setColor(new Color(200, 255, 255));
    ptx[0] -= 1;
    pty[0] += 1;
    ptx[1] -= 1;
    pty[1] += 1;
    ptx[2] -= 1;
    ptx[3] -= 1;
    ptx[4] += 1;
    ptx[5] += 1;
    ptx[6] += 1;
    pty[6] += 1;
    g.fillPolygon(ptx, pty, 7);
    if (substreamSensitive) {
        g.setColor(Color.RED);
        int[] ptx2 = new int[3];
        int[] pty2 = new int[3];
        ptx2[0] = left + 10;
        ptx2[1] = left;
        ptx2[2] = left + 10;
        pty2[0] = top;
        pty2[1] = cy;
        pty2[2] = bottom;
        g.setColor(Color.RED);
        g.drawPolygon(ptx2, pty2, 3);
        g.fillPolygon(ptx2, pty2, 3);
    }
    g.setColor(Color.BLACK);
    if (!type.equals(Block.Types.EXTPORT_OUTIN_BLOCK))
        g.drawLine(right, cy - height, right, cy + height);
    calcDiagMaxAndMin(left, right, top, bottom);
}

Output:
     if (this == driver.selBlock)
-        g.setColor(new Color(255, 255, 200));
+        g.setColor(ly);
     else


Input:
public void run() {
    gridComposite.pack();
    drawingComposite.pack();
    pageComposite.layout();
}

Output:
 public void run() {
-    gridComposite.pack();
-    drawingComposite.pack();
-    pageComposite.layout();
+    if (!pageComposite.isDisposed()) {
+        gridComposite.pack();
+        drawingComposite.pack();
+        pageComposite.layout();
+    }
 }


Input:
public void determineAccessRights(String page, State currentState) {
    if (currentState.getUserProjectRole() == ProjectRole.Acquisition_Organization_Engineer) {
        currentState.setMode(GwtModesType.NoAccess);
    } else if (currentState.getUserProjectRole() == ProjectRole.Contractor) {
        currentState.setMode(GwtModesType.NoAccess);
    } else if (currentState.getUserProjectRole() == ProjectRole.Security_Specialist) {
        currentState.setMode(GwtModesType.ReadWrite);
    } else if (currentState.getUserProjectRole() == ProjectRole.COTS_Vendor) {
        currentState.setMode(GwtModesType.ReadOnly);
    } else if (currentState.getUserProjectRole() == ProjectRole.None) {
        currentState.setMode(GwtModesType.NoAccess);
    } else if (currentState.getUserProjectRole() == ProjectRole.Administrator) {
        currentState.setMode(GwtModesType.ReadWrite);
    } else {
        currentState.setMode(GwtModesType.ReadOnly);
    }
}

Output:
 public void determineAccessRights(String page, State currentState) {
-    if (currentState.getUserProjectRole() == ProjectRole.Acquisition_Organization_Engineer) {
+    if (currentState.isSiteAdministrator() == true) {
+        currentState.setMode(GwtModesType.ReadWrite);
+    } else if (currentState.getUserProjectRole() == ProjectRole.Acquisition_Organization_Engineer) {
         currentState.setMode(GwtModesType.NoAccess);


Input:
public String getText(Object element) {
    TaxonomyNode node = (TaxonomyNode) element;
    if (node.getParent() != null && node.getParent().isUnassignedCategory())
        return null;
    Security security = node.getBackingSecurity();
    if (security == null || security.getCurrencyCode() == null)
        return null;
    String priceCurrency = security.getCurrencyCode();
    long price = security.getSecurityPrice(LocalDate.now()).getValue();
    long weightedPrice = Math.round(node.getWeight() * price / Classification.ONE_HUNDRED_PERCENT);
    if (weightedPrice == 0L)
        return Values.Share.format(0L);
    String deltaCurrency = node.getActual().getCurrencyCode();
    long delta = node.getParent().getTarget().getAmount() - node.getParent().getActual().getAmount();
    if (!deltaCurrency.equals(priceCurrency)) {
        delta = getModel().getCurrencyConverter().with(priceCurrency).convert(LocalDate.now(), Money.of(deltaCurrency, delta)).getAmount();
    }
    long shares = Math.round(delta * Values.Share.factor() * Values.Quote.factorToMoney() / weightedPrice);
    return Values.Share.format(shares);
}

Output:
     long price = security.getSecurityPrice(LocalDate.now()).getValue();
-    long weightedPrice = Math.round(node.getWeight() * price / Classification.ONE_HUNDRED_PERCENT);
+    long weightedPrice = Math.round(node.getWeight() * price / (double) Classification.ONE_HUNDRED_PERCENT);
     if (weightedPrice == 0L)


Input:
public final String[] validate(Chart cm, Object oContext) {
    final ArrayList alProblems = new ArrayList(4);
    final ExtendedItemHandle eih = (ExtendedItemHandle) oContext;
    if (DEUtil.getDataSetList(eih).size() == 0 && ChartReportItemUtil.getBindingCube(eih) == null) {
        alProblems.add(Messages.getString("String_Node_Str"));
    }
    final QueryUIHelper.SeriesQueries[] qsqa = new QueryUIHelper().getSeriesQueryDefinitions(cm);
    Collection co;
    for (int i = 0; i < qsqa.length; i++) {
        co = qsqa[i].validate();
        if (co != null) {
            alProblems.addAll(co);
        }
    }
    return (String[]) alProblems.toArray(new String[alProblems.size()]);
}

Output:
     final ExtendedItemHandle eih = (ExtendedItemHandle) oContext;
-    if (DEUtil.getDataSetList(eih).size() == 0 && ChartReportItemUtil.getBindingCube(eih) == null) {
+    if (DEUtil.getDataSetList(eih).size() == 0 && ChartXTabUtil.getBindingCube(eih) == null) {
         alProblems.add(Messages.getString("String_Node_Str"));


Input:
public ResultIterable queryTarget() throws SynchronizationException {
    return query(targetQuery.get("String_Node_Str").asString(), targetQuery, reconContext, Collections.synchronizedList(new ArrayList<String>()), reconContext.getObjectMapping().getLinkType().isTargetCaseSensitive(), QuerySide.TARGET, 0, null).getResultIterable();
}

Output:
 public ResultIterable queryTarget() throws SynchronizationException {
-    return query(targetQuery.get("String_Node_Str").asString(), targetQuery, reconContext, Collections.synchronizedList(new ArrayList<String>()), reconContext.getObjectMapping().getLinkType().isTargetCaseSensitive(), QuerySide.TARGET, 0, null).getResultIterable();
+    return query(targetQuery.get("String_Node_Str").asString(), targetQuery, reconContext, Collections.synchronizedSet(new LinkedHashSet<String>()), reconContext.getObjectMapping().getLinkType().isTargetCaseSensitive(), QuerySide.TARGET, 0, null).getResultIterable();
 }


Input:
public void craftOrGetItem(final PacketPatternSlot packetPatternSlot) {
    if (packetPatternSlot.slotItem != null && this.getCellInventory() != null) {
        final IAEItemStack out = packetPatternSlot.slotItem.copy();
        InventoryAdaptor inv = new AdaptorPlayerHand(this.getPlayerInv().player);
        final InventoryAdaptor playerInv = InventoryAdaptor.getAdaptor(this.getPlayerInv().player, EnumFacing.UP);
        if (packetPatternSlot.shift) {
            inv = playerInv;
        }
        if (!inv.simulateAdd(out.getItemStack()).isEmpty()) {
            return;
        }
        final IAEItemStack extracted = Platform.poweredExtraction(this.getPowerSource(), this.getCellInventory(), out, this.getActionSource());
        final EntityPlayer p = this.getPlayerInv().player;
        if (extracted != null) {
            inv.addItems(extracted.getItemStack());
            if (p instanceof EntityPlayerMP) {
                this.updateHeld((EntityPlayerMP) p);
            }
            this.detectAndSendChanges();
            return;
        }
        final InventoryCrafting ic = new InventoryCrafting(new ContainerNull(), 3, 3);
        final InventoryCrafting real = new InventoryCrafting(new ContainerNull(), 3, 3);
        for (int x = 0; x < 9; x++) {
            ic.setInventorySlotContents(x, packetPatternSlot.pattern[x] == null ? ItemStack.EMPTY : packetPatternSlot.pattern[x].getItemStack());
        }
        final IRecipe r = Platform.findMatchingRecipe(ic, p.world);
        if (r == null) {
            return;
        }
        final IMEMonitor<IAEItemStack> storage = this.getPatternTerminal().getItemInventory();
        final IItemList<IAEItemStack> all = storage.getStorageList();
        final ItemStack is = r.getCraftingResult(ic);
        for (int x = 0; x < ic.getSizeInventory(); x++) {
            if (!ic.getStackInSlot(x).isEmpty()) {
                final ItemStack pulled = Platform.extractItemsByRecipe(this.getPowerSource(), this.getActionSource(), storage, p.world, r, is, ic, ic.getStackInSlot(x), x, all, Actionable.MODULATE, ItemViewCell.createFilter(this.getViewCells()));
                real.setInventorySlotContents(x, pulled);
            }
        }
        final IRecipe rr = Platform.findMatchingRecipe(real, p.world);
        if (rr == r && Platform.itemComparisons().isSameItem(rr.getCraftingResult(real), is)) {
            final SlotCrafting sc = new SlotCrafting(p, real, this.cOut, 0, 0, 0);
            sc.onTake(p, is);
            for (int x = 0; x < real.getSizeInventory(); x++) {
                final ItemStack failed = playerInv.addItems(real.getStackInSlot(x));
                if (!failed.isEmpty()) {
                    p.dropItem(failed, false);
                }
            }
            inv.addItems(is);
            if (p instanceof EntityPlayerMP) {
                this.updateHeld((EntityPlayerMP) p);
            }
            this.detectAndSendChanges();
        } else {
            for (int x = 0; x < real.getSizeInventory(); x++) {
                final ItemStack failed = real.getStackInSlot(x);
                if (!failed.isEmpty()) {
                    this.getCellInventory().injectItems(AEItemStack.create(failed), Actionable.MODULATE, new MachineSource(this.getPatternTerminal()));
                }
            }
        }
    }
}

Output:
         if (rr == r && Platform.itemComparisons().isSameItem(rr.getCraftingResult(real), is)) {
-            final SlotCrafting sc = new SlotCrafting(p, real, this.cOut, 0, 0, 0);
+            final InventoryCraftResult craftingResult = new InventoryCraftResult();
+            craftingResult.setRecipeUsed(rr);
+            final SlotCrafting sc = new SlotCrafting(p, real, craftingResult, 0, 0, 0);
             sc.onTake(p, is);


Input:
private void extendGroundingsAndAddToBuilder(Predicate groundingExtension, ProbabilisticSoftLogicProblem.Builder builder, ProbabilisticSoftLogicPredicateManager predicateManager, HashSet<String> groundingsAlreadyAdded, HashSet<Integer> newPredicates) {
    boolean[] bodyNegations = new boolean[this.Body.size()];
    for (int i = 0; i < this.Body.size(); ++i) {
        bodyNegations[i] = this.Body.get(i).IsNegated;
    }
    boolean[] headNegations = new boolean[this.Head.size()];
    for (int i = 0; i < this.Head.size(); ++i) {
        headNegations[i] = this.Head.get(i).IsNegated;
    }
    List<List<String>> allArgumentGroundings = new ArrayList<>();
    for (ArgumentGroundingSources argumentGroundingSource : this.ArgumentGroundingSources) {
        HashSet<String> argumentGroundings = new HashSet<>();
        for (GroundingSource source : argumentGroundingSource.GroundingSources) {
            argumentGroundings.addAll(predicateManager.getArgumentGroundings(this.Body.get(source.IndexPredicate).Name, source.IndexArgument));
        }
        allArgumentGroundings.add(new ArrayList<>(argumentGroundings));
    }
    HashSet<String> visitedGroundings = new HashSet<>();
    for (int indexInsertion = 0; indexInsertion < this.Body.size(); ++indexInsertion) {
        if (this.Body.get(indexInsertion).Name.equals(groundingExtension.Name) && this.Body.get(indexInsertion).Arguments.size() == groundingExtension.Arguments.size()) {
            HashMap<String, String> extensionGroundings = new HashMap<>();
            for (int indexExtensionArgument = 0; indexExtensionArgument < groundingExtension.Arguments.size(); ++indexExtensionArgument) {
                extensionGroundings.put(this.Body.get(indexInsertion).Arguments.get(indexExtensionArgument), groundingExtension.Arguments.get(indexExtensionArgument));
            }
            String visitedKey = String.join("String_Node_Str", extensionGroundings.keySet());
            if (!visitedGroundings.add(visitedKey)) {
                continue;
            }
            List<List<String>> argumentValuesToTry = new ArrayList<>();
            for (ArgumentGroundingSources sources : this.ArgumentGroundingSources) {
                String extensionVal = extensionGroundings.getOrDefault(sources.Name, null);
                if (extensionVal != null) {
                    argumentValuesToTry.add(Arrays.asList(extensionVal));
                } else {
                    HashSet<String> availableValues = new HashSet<>();
                    for (GroundingSource source : sources.GroundingSources) {
                        availableValues.addAll(predicateManager.getArgumentGroundings(this.Body.get(source.IndexPredicate).Name, source.IndexPredicate));
                    }
                    argumentValuesToTry.add(new ArrayList<>(availableValues));
                }
            }
            CartesianProductIterator<String> argumentInstanceIterator = new CartesianProductIterator<>(argumentValuesToTry);
            for (List<String> argumentInstance : argumentInstanceIterator) {
                HashMap<String, String> argumentToGrounding = new HashMap<>();
                StringBuilder groundingStringBuilder = new StringBuilder();
                for (int indexArgument = 0; indexArgument < this.ArgumentGroundingSources.size(); ++indexArgument) {
                    argumentToGrounding.put(this.ArgumentGroundingSources.get(indexArgument).Name, argumentInstance.get(indexArgument));
                    if (indexArgument > 0) {
                        groundingStringBuilder.append("String_Node_Str");
                    }
                    groundingStringBuilder.append(this.ArgumentGroundingSources.get(indexArgument).Name);
                    groundingStringBuilder.append("String_Node_Str");
                    groundingStringBuilder.append(argumentInstance.get(indexArgument));
                }
                String groundingString = groundingStringBuilder.toString();
                if (groundingsAlreadyAdded.contains(groundingString)) {
                    continue;
                }
                if (!this.getIsGroundedOrderingAllowed(argumentToGrounding)) {
                    continue;
                }
                Map.Entry<int[], boolean[]> bodyIdResult = Rule.getPredicateIds(this.Body, argumentToGrounding, predicateManager, false);
                double observedBodyConstant = 0;
                for (int indexBody = 0; indexBody < this.Body.size(); ++indexBody) {
                    int bodyId = bodyIdResult.getKey()[indexBody];
                    double observedValue = bodyId < 0 ? 0 : predicateManager.getObservedWeight(bodyId);
                    if (!Double.isNaN(observedValue)) {
                        if (this.Body.get(indexBody).IsNegated)
                            observedBodyConstant -= observedValue;
                        else
                            observedBodyConstant += observedValue - 1;
                    }
                }
                if (observedBodyConstant + 1 <= 0) {
                    continue;
                }
                groundingsAlreadyAdded.add(groundingString);
                Map.Entry<int[], boolean[]> headIdResult = Rule.getPredicateIds(this.Head, argumentToGrounding, predicateManager, true);
                for (int indexHead = 0; indexHead < this.Head.size(); ++indexHead) {
                    if (headIdResult.getValue()[indexHead]) {
                        newPredicates.add(headIdResult.getKey()[indexHead]);
                    }
                }
                if (Double.isNaN(this.Weight)) {
                    builder.addRule(headIdResult.getKey(), bodyIdResult.getKey(), headNegations, bodyNegations, 1, 1000);
                } else {
                    builder.addRule(headIdResult.getKey(), bodyIdResult.getKey(), headNegations, bodyNegations, this.Power, this.Weight);
                }
            }
        }
    }
}

Output:
                     for (GroundingSource source : sources.GroundingSources) {
-                        availableValues.addAll(predicateManager.getArgumentGroundings(this.Body.get(source.IndexPredicate).Name, source.IndexPredicate));
+                        availableValues.addAll(predicateManager.getArgumentGroundings(this.Body.get(source.IndexPredicate).Name, source.IndexArgument));
                     }


Input:
public static IProblem createIncompleteObjectMappingProblem(IAUTMainPO aut) {
    return new Problem(NLS.bind(Messages.ProblemIncompleteObjectMappingMarkerText, aut.getName()), new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.ProblemIncompleteObjectMappingTooltip), aut.getName(), ProblemType.REASON_OM_INCOMPLETE);
}

Output:
 public static IProblem createIncompleteObjectMappingProblem(IAUTMainPO aut) {
-    return new Problem(NLS.bind(Messages.ProblemIncompleteObjectMappingMarkerText, aut.getName()), new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.ProblemIncompleteObjectMappingTooltip), aut.getName(), ProblemType.REASON_OM_INCOMPLETE);
+    String autName = aut.getName();
+    return new Problem(NLS.bind(Messages.ProblemIncompleteObjectMappingMarkerText, autName), new Status(IStatus.ERROR, Activator.PLUGIN_ID, NLS.bind(Messages.ProblemIncompleteObjectMappingTooltip, autName)), autName, ProblemType.REASON_OM_INCOMPLETE);
 }


Input:
private boolean allArgsCheapToExpand(Exp exp) {
    if (exp instanceof NamedSetExpr) {
        exp = ((NamedSetExpr) exp).getNamedSet().getExp();
    }
    for (Exp arg : ((ResolvedFunCall) exp).getArgs()) {
        if (arg instanceof ResolvedFunCall) {
            if (!cheapFuns.contains(((ResolvedFunCall) arg).getFunName())) {
                return false;
            }
        } else if (!(arg instanceof MemberExpr)) {
            return false;
        }
    }
    return true;
}

Output:
 private boolean allArgsCheapToExpand(Exp exp) {
-    if (exp instanceof NamedSetExpr) {
+    while (exp instanceof NamedSetExpr) {
         exp = ((NamedSetExpr) exp).getNamedSet().getExp();


Input:
private void setupSchedulePlanServiceWithActivity(Activity activity) {
    SchedulePlan plan = SchedulePlan.create();
    Activity activityCopy = new Activity.Builder().withActivity(activity).build();
    ScheduledActivity scheduledActivity = ScheduledActivity.create();
    scheduledActivity.setActivity(activity);
    ScheduledActivity scheduledActivityCopy = ScheduledActivity.create();
    scheduledActivityCopy.setActivity(activityCopy);
    List<ScheduledActivity> scheduledActivityList = ImmutableList.of(scheduledActivity, scheduledActivityCopy);
    ActivityScheduler mockScheduler = mock(ActivityScheduler.class);
    when(mockScheduler.getScheduledActivities(plan, SCHEDULE_CONTEXT)).thenReturn(scheduledActivityList);
    Schedule mockSchedule = mock(Schedule.class);
    when(mockSchedule.getScheduler()).thenReturn(mockScheduler);
    SimpleScheduleStrategy strategy = new SimpleScheduleStrategy();
    strategy.setSchedule(mockSchedule);
    plan.setStrategy(strategy);
    when(mockSchedulePlanService.getSchedulePlans(ClientInfo.UNKNOWN_CLIENT, TestConstants.TEST_STUDY)).thenReturn(ImmutableList.of(plan));
}

Output:
     SchedulePlan plan = SchedulePlan.create();
-    Activity activityCopy = new Activity.Builder().withActivity(activity).build();
+    Activity activityCopy1 = new Activity.Builder().withActivity(activity).withLabel(ACTIVITY_LABEL_PREFIX + "String_Node_Str").build();
+    Activity activityCopy2 = new Activity.Builder().withActivity(activity).withLabel(ACTIVITY_LABEL_PREFIX + "String_Node_Str").build();
     ScheduledActivity scheduledActivity = ScheduledActivity.create();


Input:
protected void initComponent() {
    paramFields = new ArrayList<JTextField>();
    jlbParameters = new JLabel("String_Node_Str");
    jtfExpectedValue = new JTextField(10);
    jlbExpectedValue = new JLabel("String_Node_Str");
    jlbExpectedValueError = new JLabel("String_Node_Str");
    jlbExpectedValueError.setForeground(Color.red);
    jlbMethodDescription = new JLabel();
    topPanel = new JPanel(new FlowLayout());
    bottomPanel = new JPanel(new FlowLayout());
    List<Method> methodsList = model.getMethods().getList();
    jcbMethods = new JComboBox(createComboBoxArray(methodsList));
    jcbMethods.addActionListener(this);
    topPanel.add(jcbMethods);
    topPanel.add(jlbExpectedValue);
    topPanel.add(jlbExpectedValueError);
    topPanel.add(jtfExpectedValue);
    topPanel.add(jlbParameters);
    add(topPanel);
    add(bottomPanel);
}

Output:
 protected void initComponent() {
-    paramFields = new ArrayList<JTextField>();
+    paramFields = new ArrayList<JTextField>(10);
     jlbParameters = new JLabel("String_Node_Str");


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
        Cards cardsToHand = new CardsImpl();
        for (Permanent permanent : game.getBattlefield().getActivePermanents(filter, source.getControllerId(), source.getSourceId(), game)) {
            cardsToHand.add(permanent);
        }
        controller.moveCards(cardsToHand, Zone.HAND, source, game);
        return true;
    }
    return false;
}

Output:
     if (controller != null) {
-        Cards cardsToHand = new CardsImpl();
+        Set<Card> permanentsToHand = new HashSet<>();
         for (Permanent permanent : game.getBattlefield().getActivePermanents(filter, source.getControllerId(), source.getSourceId(), game)) {


Input:
static TaskRecord restoreFromXml(XmlPullParser in, ActivityStackSupervisor stackSupervisor) throws IOException, XmlPullParserException {
    Intent intent = null;
    Intent affinityIntent = null;
    ArrayList<ActivityRecord> activities = new ArrayList<ActivityRecord>();
    ComponentName realActivity = null;
    ComponentName origActivity = null;
    String affinity = null;
    boolean rootHasReset = false;
    boolean autoRemoveRecents = false;
    boolean askedCompatMode = false;
    int taskType = ActivityRecord.APPLICATION_ACTIVITY_TYPE;
    int userId = 0;
    int effectiveUid = -1;
    String lastDescription = null;
    long firstActiveTime = -1;
    long lastActiveTime = -1;
    long lastTimeOnTop = 0;
    boolean neverRelinquishIdentity = true;
    int taskId = -1;
    final int outerDepth = in.getDepth();
    ActivityManager.TaskDescription taskDescription = new ActivityManager.TaskDescription();
    int taskAffiliation = -1;
    int taskAffiliationColor = 0;
    int prevTaskId = -1;
    int nextTaskId = -1;
    int callingUid = -1;
    String callingPackage = "String_Node_Str";
    for (int attrNdx = in.getAttributeCount() - 1; attrNdx >= 0; --attrNdx) {
        final String attrName = in.getAttributeName(attrNdx);
        final String attrValue = in.getAttributeValue(attrNdx);
        if (TaskPersister.DEBUG)
            Slog.d(TaskPersister.TAG, "String_Node_Str" + attrName + "String_Node_Str" + attrValue);
        if (ATTR_TASKID.equals(attrName)) {
            taskId = Integer.valueOf(attrValue);
        } else if (ATTR_REALACTIVITY.equals(attrName)) {
            realActivity = ComponentName.unflattenFromString(attrValue);
        } else if (ATTR_ORIGACTIVITY.equals(attrName)) {
            origActivity = ComponentName.unflattenFromString(attrValue);
        } else if (ATTR_AFFINITY.equals(attrName)) {
            affinity = attrValue;
        } else if (ATTR_ROOTHASRESET.equals(attrName)) {
            rootHasReset = Boolean.valueOf(attrValue);
        } else if (ATTR_AUTOREMOVERECENTS.equals(attrName)) {
            autoRemoveRecents = Boolean.valueOf(attrValue);
        } else if (ATTR_ASKEDCOMPATMODE.equals(attrName)) {
            askedCompatMode = Boolean.valueOf(attrValue);
        } else if (ATTR_USERID.equals(attrName)) {
            userId = Integer.valueOf(attrValue);
        } else if (ATTR_EFFECTIVE_UID.equals(attrName)) {
            effectiveUid = Integer.valueOf(attrValue);
        } else if (ATTR_TASKTYPE.equals(attrName)) {
            taskType = Integer.valueOf(attrValue);
        } else if (ATTR_FIRSTACTIVETIME.equals(attrName)) {
            firstActiveTime = Long.valueOf(attrValue);
        } else if (ATTR_LASTACTIVETIME.equals(attrName)) {
            lastActiveTime = Long.valueOf(attrValue);
        } else if (ATTR_LASTDESCRIPTION.equals(attrName)) {
            lastDescription = attrValue;
        } else if (ATTR_LASTTIMEMOVED.equals(attrName)) {
            lastTimeOnTop = Long.valueOf(attrValue);
        } else if (ATTR_NEVERRELINQUISH.equals(attrName)) {
            neverRelinquishIdentity = Boolean.valueOf(attrValue);
        } else if (readTaskDescriptionAttribute(taskDescription, attrName, attrValue)) {
        } else if (ATTR_TASK_AFFILIATION.equals(attrName)) {
            taskAffiliation = Integer.valueOf(attrValue);
        } else if (ATTR_PREV_AFFILIATION.equals(attrName)) {
            prevTaskId = Integer.valueOf(attrValue);
        } else if (ATTR_NEXT_AFFILIATION.equals(attrName)) {
            nextTaskId = Integer.valueOf(attrValue);
        } else if (ATTR_TASK_AFFILIATION_COLOR.equals(attrName)) {
            taskAffiliationColor = Integer.valueOf(attrValue);
        } else if (ATTR_CALLING_UID.equals(attrName)) {
            callingUid = Integer.valueOf(attrValue);
        } else if (ATTR_CALLING_PACKAGE.equals(attrName)) {
            callingPackage = attrValue;
        } else {
            Slog.w(TAG, "String_Node_Str" + attrName);
        }
    }
    int event;
    while (((event = in.next()) != XmlPullParser.END_DOCUMENT) && (event != XmlPullParser.END_TAG || in.getDepth() < outerDepth)) {
        if (event == XmlPullParser.START_TAG) {
            final String name = in.getName();
            if (TaskPersister.DEBUG)
                Slog.d(TaskPersister.TAG, "String_Node_Str" + name);
            if (TAG_AFFINITYINTENT.equals(name)) {
                affinityIntent = Intent.restoreFromXml(in);
            } else if (TAG_INTENT.equals(name)) {
                intent = Intent.restoreFromXml(in);
            } else if (TAG_ACTIVITY.equals(name)) {
                ActivityRecord activity = ActivityRecord.restoreFromXml(in, taskId, stackSupervisor);
                if (TaskPersister.DEBUG)
                    Slog.d(TaskPersister.TAG, "String_Node_Str" + activity);
                if (activity != null) {
                    activities.add(activity);
                }
            } else {
                Slog.e(TAG, "String_Node_Str" + name);
                XmlUtils.skipCurrentTag(in);
            }
        }
    }
    if (lastActiveTime >= 0) {
        taskDescription.setIcon(TaskPersister.restoreImage(createLastTaskDescriptionIconFilename(taskId, lastActiveTime)));
    }
    if (effectiveUid <= 0) {
        Intent checkIntent = intent != null ? intent : affinityIntent;
        effectiveUid = 0;
        if (checkIntent != null) {
            IPackageManager pm = AppGlobals.getPackageManager();
            try {
                ApplicationInfo ai = pm.getApplicationInfo(checkIntent.getComponent().getPackageName(), PackageManager.GET_UNINSTALLED_PACKAGES | PackageManager.GET_DISABLED_COMPONENTS, userId);
                if (ai != null) {
                    effectiveUid = ai.uid;
                }
            } catch (RemoteException e) {
            }
        }
        Slog.w(TAG, "String_Node_Str" + taskId + "String_Node_Str" + checkIntent + "String_Node_Str" + effectiveUid);
    }
    final TaskRecord task = new TaskRecord(stackSupervisor.mService, taskId, intent, affinityIntent, affinity, realActivity, origActivity, rootHasReset, autoRemoveRecents, askedCompatMode, taskType, userId, effectiveUid, lastDescription, activities, firstActiveTime, lastActiveTime, lastTimeOnTop, neverRelinquishIdentity, taskDescription, taskAffiliation, prevTaskId, nextTaskId, taskAffiliationColor, callingUid, callingPackage);
    for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
        activities.get(activityNdx).task = task;
    }
    if (ActivityManagerService.DEBUG_RECENTS)
        Slog.d(TAG, "String_Node_Str" + task);
    return task;
}

Output:
     }
-    final TaskRecord task = new TaskRecord(stackSupervisor.mService, taskId, intent, affinityIntent, affinity, realActivity, origActivity, rootHasReset, autoRemoveRecents, askedCompatMode, taskType, userId, effectiveUid, lastDescription, activities, firstActiveTime, lastActiveTime, lastTimeOnTop, neverRelinquishIdentity, taskDescription, taskAffiliation, prevTaskId, nextTaskId, taskAffiliationColor, callingUid, callingPackage);
+    final TaskRecord task = new TaskRecord(stackSupervisor.mService, taskId, intent, affinityIntent, affinity, rootAffinity, realActivity, origActivity, rootHasReset, autoRemoveRecents, askedCompatMode, taskType, userId, effectiveUid, lastDescription, activities, firstActiveTime, lastActiveTime, lastTimeOnTop, neverRelinquishIdentity, taskDescription, taskAffiliation, prevTaskId, nextTaskId, taskAffiliationColor, callingUid, callingPackage);
     for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {


Input:
private Stage getStageByTitle(final String title, final String operator) {
    Stage result = null;
    try {
        result = EventThreadQueuerJavaFXImpl.invokeAndWait("String_Node_Str", new Callable<Stage>() {

            public Stage call() throws Exception {
                List<? extends Stage> stages = ComponentHandler.getAssignableFrom(Stage.class);
                for (final Stage stage : stages) {
                    if (MatchUtil.getInstance().match(stage.getTitle(), title, operator)) {
                        return stage;
                    }
                }
                return null;
            }
        });
    } catch (IllegalStateException e) {
    }
    return result;
}

Output:
     Stage result = null;
-    try {
-        result = EventThreadQueuerJavaFXImpl.invokeAndWait("String_Node_Str", new Callable<Stage>() {
+    result = EventThreadQueuerJavaFXImpl.invokeAndWait("String_Node_Str", new Callable<Stage>() {


Input:
public void setUp() throws Exception {
    TurkishMorphParser morphParser = TurkishMorphParser.newBuilder().addDefaultDictionaries().build();
    parser = new TurkishSentenceParser(morphParser, new Z3MarkovModelDisambiguator());
}

Output:
 public void setUp() throws Exception {
-    TurkishMorphParser morphParser = TurkishMorphParser.newBuilder().addDefaultDictionaries().build();
+    TurkishMorphParser morphParser = TurkishMorphParser.builder().addDefaultDictionaries().build();
     parser = new TurkishSentenceParser(morphParser, new Z3MarkovModelDisambiguator());


Input:
private void processStopEditing0(String token, Worksheet sheet, int rowIdx, int colIdx, Object value) {
    try {
        Utils.setEditText(sheet, rowIdx, colIdx, value == null ? "String_Node_Str" : value.toString());
        JSONObj result = new JSONObj();
        result.setData("String_Node_Str", rowIdx);
        result.setData("String_Node_Str", colIdx);
        result.setData("String_Node_Str", "String_Node_Str");
        result.setData("String_Node_Str", "String_Node_Str");
        updateRange(sheet, Utils.getSheetUuid(sheet), colIdx, rowIdx, colIdx, rowIdx);
        smartUpdate("String_Node_Str", new String[] { token, Utils.getSheetUuid(sheet), result.toString() });
    } catch (RuntimeException x) {
        processCancelEditing0(token, sheet, rowIdx, colIdx);
        if (x instanceof FormulaParseException) {
            showFormulaError((FormulaParseException) x);
        } else {
            throw x;
        }
    }
}

Output:
         result.setData("String_Node_Str", "String_Node_Str");
-        updateRange(sheet, Utils.getSheetUuid(sheet), colIdx, rowIdx, colIdx, rowIdx);
+        if (getPreloadColumnSize() > 0 && getPreloadRowSize() > 0) {
+            updateRange(sheet, Utils.getSheetUuid(sheet), colIdx, rowIdx, colIdx, rowIdx);
+        }
         smartUpdate("String_Node_Str", new String[] { token, Utils.getSheetUuid(sheet), result.toString() });


Input:
public final <T> Attribute<T> internalInitializeAttribute(IAttributeType attributeType, int attributeId, int gammaId, ModificationType modificationType, boolean markDirty, Object... data) throws OseeCoreException {
    Attribute<T> attribute = createAttribute(attributeType);
    attribute.internalInitialize(attributeType, this, modificationType, attributeId, gammaId, markDirty, false);
    attribute.getAttributeDataProvider().loadData(data);
    return attribute;
}

Output:
     Attribute<T> attribute = createAttribute(attributeType);
-    attribute.internalInitialize(attributeType, this, modificationType, attributeId, gammaId, markDirty, false);
+    attribute.internalInitialize(attributeType, this, modificationType, applicabilityId, attributeId, gammaId, markDirty, false);
     attribute.getAttributeDataProvider().loadData(data);


Input:
private void addReadFile(FileObject fileObject) {
    Preconditions.checkState(result == null);
    if (!(fileObject instanceof JavaFileObject)) {
        return;
    }
    JavaFileObject javaFileObject = (JavaFileObject) fileObject;
    if (javaFileObject.getKind() != JavaFileObject.Kind.CLASS) {
        return;
    }
    Matcher classFileMatcher = CLASS_FILE_PATTERN.matcher(javaFileObject.toUri().toString());
    boolean matches = classFileMatcher.matches();
    if (!matches) {
        return;
    }
    resultBuilder.put(Paths.get(classFileMatcher.group("String_Node_Str")), Paths.get(classFileMatcher.group("String_Node_Str")));
}

Output:
     }
-    Matcher classFileMatcher = CLASS_FILE_PATTERN.matcher(javaFileObject.toUri().toString());
-    boolean matches = classFileMatcher.matches();
-    if (!matches) {
+    URI classFileJarUri = javaFileObject.toUri();
+    if (!classFileJarUri.getScheme().equals(JAR_SCHEME)) {
         return;


Input:
public void onClick(View v) {
    if (mTitleEt.getText().toString().equals("String_Node_Str")) {
        Snackbari.showS(mTitleEt, "String_Node_Str");
        return;
    } else if (mPriceEt.getText().toString().equals("String_Node_Str")) {
        Snackbari.showS(mTitleEt, "String_Node_Str" + "String_Node_Str");
        return;
    } else if (mDescriptionEt.getText().toString().equals("String_Node_Str")) {
        Snackbari.showS(mTitleEt, "String_Node_Str");
        return;
    } else if (category == null) {
        Snackbari.showS(mTitleEt, "String_Node_Str");
        return;
    } else if (city == null) {
        Snackbari.showS(mTitleEt, "String_Node_Str");
        return;
    } else if (myGift.giftImages.size() == 0) {
        Snackbari.showS(mTitleEt, "String_Node_Str");
        return;
    }
    Gift tempGift = new Gift(mDescriptionEt.getText().toString(), region != null ? (getPlaceNameById(city.id) + "String_Node_Str" + getPlaceNameById(region.id)) : getPlaceNameById(city.id), mTitleEt.getText().toString(), mPriceEt.getText().toString(), category.categoryId, city.id, (region == null ? "String_Node_Str" : region.id), myGift.giftImages);
    if (editVersion) {
        tempGift.giftId = myGift.giftId;
        (new ApiRequest(context, RegisterGiftActivity.this)).editGift(tempGift);
    } else {
        (new ApiRequest(context, RegisterGiftActivity.this)).registerGift(tempGift);
        deleteSavedGift();
    }
    mToolbarSendBtnTv.setVisibility(View.INVISIBLE);
    mSendProgressView.setVisibility(View.VISIBLE);
}

Output:
         (new ApiRequest(context, RegisterGiftActivity.this)).registerGift(tempGift);
-        deleteSavedGift();
+        AppController.deleteSavedGift();
     }


Input:
public void testOperationRedo() throws Exception {
    final HazelcastInstance hz1 = Hazelcast.newHazelcastInstance();
    final HazelcastInstance hz2 = Hazelcast.newHazelcastInstance();
    ClientConfig clientConfig = new ClientConfig();
    clientConfig.setRedoOperation(true);
    HazelcastInstance client = HazelcastClient.newHazelcastClient(clientConfig);
    final Thread thread = new Thread() {
        public void run() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            hz1.getLifecycleService().shutdown();
        }
    };
    final IMap map = client.getMap("String_Node_Str");
    thread.start();
    int expected = 1000;
    for (int i = 0; i < expected; i++) {
        map.put(i, "String_Node_Str" + i);
    }
    thread.join();
    assertEquals(expected, map.size());
}

Output:
     final HazelcastInstance hz1 = Hazelcast.newHazelcastInstance();
-    final HazelcastInstance hz2 = Hazelcast.newHazelcastInstance();
+    Hazelcast.newHazelcastInstance();
     ClientConfig clientConfig = new ClientConfig();


Input:
public <T extends Email> T newEmail(final T email) {
    try {
        ifset("String_Node_Str", p -> {
            email.setAuthentication(mail.getString(p), mail.getString("String_Node_Str"));
        });
        ifset("String_Node_Str", p -> email.setBcc(address(strList(p))));
        ifset("String_Node_Str", p -> email.setBounceAddress(mail.getString(p)));
        ifset("String_Node_Str", p -> email.setCc(address(strList(p))));
        email.setCharset(mail.getString("String_Node_Str"));
        ifset("String_Node_Str", p -> email.setDebug(mail.getBoolean(p)));
        ifset("String_Node_Str", p -> email.setFrom(mail.getString(p)));
        ifset("String_Node_Str", p -> email.setHostName(mail.getString(p)));
        ifset("String_Node_Str", p -> {
            if (email instanceof HtmlEmail) {
                ((HtmlEmail) email).setHtmlMsg(mail.getString(p));
            } else {
                email.setMsg(mail.getString(p));
            }
        });
        ifset("String_Node_Str", p -> email.setReplyTo(address(mail.getStringList(p))));
        ifset("String_Node_Str", p -> email.setSendPartial(mail.getBoolean(p)));
        ifset("String_Node_Str", p -> email.setSmtpPort(mail.getInt(p)));
        ifset("String_Node_Str", p -> email.setSocketConnectionTimeout((int) mail.getDuration(p, TimeUnit.MILLISECONDS)));
        ifset("String_Node_Str", p -> email.setSocketTimeout((int) mail.getDuration(p, TimeUnit.MILLISECONDS)));
        ifset("String_Node_Str", p -> email.setSSLCheckServerIdentity(mail.getBoolean(p)));
        ifset("String_Node_Str", p -> email.setSSLOnConnect(mail.getBoolean(p)));
        ifset("String_Node_Str", p -> email.setSslSmtpPort(mail.getString(p)));
        ifset("String_Node_Str", p -> email.setStartTLSEnabled(mail.getBoolean(p)));
        ifset("String_Node_Str", p -> email.setStartTLSRequired(mail.getBoolean(p)));
        ifset("String_Node_Str", p -> email.setSubject(mail.getString(p)));
        ifset("String_Node_Str", p -> email.setTo(address(strList(p))));
        return email;
    } catch (Exception ex) {
        throw new IllegalArgumentException(ex);
    }
}

Output:
     try {
-        ifset("String_Node_Str", p -> {
-            email.setAuthentication(mail.getString(p), mail.getString("String_Node_Str"));
-        });
+        ifset("String_Node_Str", p -> email.setAuthentication(mail.getString(p), mail.getString("String_Node_Str")));
         ifset("String_Node_Str", p -> email.setBcc(address(strList(p))));


Input:
private void _testPreStartedMasterServer() {
    Connection conn = null;
    String db = masterDatabasePath + "String_Node_Str" + ReplicationRun.masterDbSubPath + "String_Node_Str" + replicatedDb;
    String connectionURL = "String_Node_Str" + "String_Node_Str" + masterServerHost + "String_Node_Str" + masterServerPort + "String_Node_Str" + db + "String_Node_Str" + "String_Node_Str" + slaveServerHost + "String_Node_Str" + slaveServerPort;
    util.DEBUG("String_Node_Str" + connectionURL);
    try {
        conn = DriverManager.getConnection(connectionURL);
    } catch (SQLException se) {
        int ec = se.getErrorCode();
        String ss = se.getSQLState();
        String msg = ec + "String_Node_Str" + ss + "String_Node_Str" + se.getMessage();
        util.DEBUG("String_Node_Str" + msg);
        assertTrue("String_Node_Str" + msg, "String_Node_Str".equals(ss));
        util.DEBUG("String_Node_Str");
        return;
    }
    assertTrue("String_Node_Str" + db + "String_Node_Str", false);
}

Output:
     Connection conn = null;
-    String db = masterDatabasePath + "String_Node_Str" + ReplicationRun.masterDbSubPath + "String_Node_Str" + replicatedDb;
+    String db = masterDatabasePath + FS + ReplicationRun.masterDbSubPath + FS + replicatedDb;
     String connectionURL = "String_Node_Str" + "String_Node_Str" + masterServerHost + "String_Node_Str" + masterServerPort + "String_Node_Str" + db + "String_Node_Str" + "String_Node_Str" + slaveServerHost + "String_Node_Str" + slaveServerPort;


Input:
public String getAttributeText() {
    Assert.isNotNull(this.attrText);
    return this.attrText;
}

Output:
 public String getAttributeText() {
-    Assert.isNotNull(this.attrText);
+    Assert.isNotNull(this.attrText, "String_Node_Str");
     return this.attrText;


Input:
private String findScriptUID() {
    Object name = runFunction("String_Node_Str", new Object[] {});
    try {
        if ((String) name == null) {
            throw new ClassCastException();
        }
        return (String) name;
    } catch (ClassCastException e) {
        DragonetServer.instance().getLogger().warn("String_Node_Str" + this.name + "String_Node_Str");
        DragonetServer.instance().getLogger().warn("String_Node_Str");
        return "String_Node_Str";
    }
}

Output:
     } catch (ClassCastException e) {
-        DragonetServer.instance().getLogger().warn("String_Node_Str" + this.name + "String_Node_Str");
+        DragonetServer.instance().getLogger().warn("String_Node_Str" + this.getName() + "String_Node_Str");
         DragonetServer.instance().getLogger().warn("String_Node_Str");


Input:
public Communication getRoot() {
    return null;
}

Output:
 public Communication getRoot() {
-    return null;
+    return this.csc.getRoot();
 }


Input:
private void splitIntoMultipleEventsAndPost(MotionEvent event, RainbowInputController rainbowInputController) {
    float px = rainbowInputController.getX();
    float py = rainbowInputController.getY();
    float diffX = event.getX() - px;
    float diffY = event.getY() - py;
    int divisions = getDivisionsFor(event);
    for (int i = 0; i < divisions; i++) {
        float newEventX = px + diffX * (i + 1) / 2;
        float newEventY = py + diffY * (i + 1) / 2;
        MotionEvent subEvent = obtainEventWithNewPosition(event, newEventX, newEventY);
        rainbowInputController.postEvent(subEvent, rainbow.getRainbowDrawer());
    }
}

Output:
     int divisions = getDivisionsFor(event);
-    for (int i = 0; i < divisions; i++) {
-        float newEventX = px + diffX * (i + 1) / 2;
-        float newEventY = py + diffY * (i + 1) / 2;
+    for (int i = 1; i <= divisions; i++) {
+        float newEventX = px + diffX * i / divisions;
+        float newEventY = py + diffY * i / divisions;
         MotionEvent subEvent = obtainEventWithNewPosition(event, newEventX, newEventY);


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (debug)
        Log.d(TAG, "String_Node_Str");
    mDecryptedText = null;
    mSelectionStart = 0;
    mSelectionStop = 0;
    if (savedInstanceState != null) {
        mOriginalContent = savedInstanceState.getString(BUNDLE_ORIGINAL_CONTENT);
        mState = savedInstanceState.getInt(BUNDLE_STATE);
        mUri = Uri.parse(savedInstanceState.getString(BUNDLE_URI));
        mSelectionStart = savedInstanceState.getInt(BUNDLE_SELECTION_START);
        mSelectionStop = savedInstanceState.getInt(BUNDLE_SELECTION_STOP);
        mFileContent = savedInstanceState.getString(BUNDLE_FILE_CONTENT);
        if (mApplyText == null && mApplyTextBefore == null && mApplyTextAfter == null) {
            mApplyText = savedInstanceState.getString(BUNDLE_APPLY_TEXT);
            mApplyTextBefore = savedInstanceState.getString(BUNDLE_APPLY_TEXT_BEFORE);
            mApplyTextAfter = savedInstanceState.getString(BUNDLE_APPLY_TEXT_AFTER);
        }
    } else {
        final Intent intent = getIntent();
        final String action = intent.getAction();
        if (Intent.ACTION_EDIT.equals(action) || Intent.ACTION_VIEW.equals(action)) {
            mState = STATE_EDIT;
            mUri = intent.getData();
            if (mUri.getScheme().equals("String_Node_Str")) {
                mState = STATE_EDIT_NOTE_FROM_SDCARD;
                mFileContent = readFile(FileUriUtils.getFile(mUri));
            }
        } else if (Intent.ACTION_INSERT.equals(action)) {
            ContentValues values = new ContentValues(1);
            String theme = getMostRecentlyUsedTheme();
            values.put(Notes.THEME, theme);
            String tags = intent.getStringExtra(NotepadInternalIntents.EXTRA_TAGS);
            values.put(Notes.TAGS, tags);
            mState = STATE_INSERT;
            mUri = getContentResolver().insert(intent.getData(), values);
            if (mUri == null) {
                Log.e(TAG, "String_Node_Str" + getIntent().getData());
                finish();
                return;
            }
            setResult(RESULT_OK, intent);
        } else {
            Log.e(TAG, "String_Node_Str");
            finish();
            return;
        }
    }
    requestWindowFeature(Window.FEATURE_RIGHT_ICON);
    setContentView(R.layout.note_editor);
    mText = (EditText) findViewById(R.id.note);
    if (mState == STATE_EDIT_NOTE_FROM_SDCARD) {
        mText.addTextChangedListener(mTextWatcherSdCard);
    }
    if (mState != STATE_EDIT_NOTE_FROM_SDCARD) {
        mCursor = managedQuery(mUri, PROJECTION, null, null, null);
    } else {
        mCursor = null;
    }
}

Output:
         Log.d(TAG, "String_Node_Str");
-    mDecryptedText = null;
+    mDecryptedText = sDecryptedText;
+    if (sDecryptedText != null) {
+        EncryptActivity.cancelEncrypt();
+        if (EncryptActivity.getPendingEncryptActivities() == 0) {
+            if (debug)
+                Log.d(TAG, "String_Node_Str");
+            sDecryptedText = null;
+        }
+    }
     mSelectionStart = 0;


Input:
public ArrayList<DownloadLink> decryptIt(CryptedLink param, ProgressController progress) throws Exception {
    ArrayList<DownloadLink> decryptedLinks = new ArrayList<DownloadLink>();
    String parameter = param.toString();
    br.setCookiesExclusive(true);
    br.setReadTimeout(5 * 60 * 1000);
    br.setConnectTimeout(5 * 60 * 1000);
    for (int retry = 1; retry <= 10; retry++) {
        try {
            br.clearCookies(this.getHost());
            br.getPage(parameter);
            String pass = br.getRegex(Pattern.compile("String_Node_Str", Pattern.CASE_INSENSITIVE | Pattern.DOTALL)).getMatch(0);
            Vector<String> passwords = new Vector<String>();
            passwords.add("String_Node_Str");
            if (pass != null && !pass.equals("String_Node_Str")) {
                passwords.add(pass);
            }
            Form form = br.getForm(1);
            if (form != null && form.containsHTML("String_Node_Str")) {
                File file;
                int i = 10;
                while (true) {
                    i--;
                    if (i <= 0) {
                        logger.severe("String_Node_Str");
                        return null;
                    }
                    file = this.getLocalCaptchaFile(this);
                    Browser.download(file, br.cloneBrowser().openGetConnection("String_Node_Str"));
                    try {
                        File f = convert(file);
                        if (f == null || !f.exists())
                            continue;
                        file = f;
                        break;
                    } catch (Exception e) {
                        continue;
                    }
                }
                String captcha = getCaptchaCode(file, this, param);
                form.put("String_Node_Str", captcha);
                br.submitForm(form);
                if (br.containsHTML("String_Node_Str"))
                    continue;
            }
            Form[] forms = br.getForms();
            progress.setRange(forms.length);
            DDLWarez_Linkgrabber[] DDLWarez_Linkgrabbers = new DDLWarez_Linkgrabber[forms.length];
            for (int i = 0; i < forms.length; ++i) {
                synchronized (Worker_Delay) {
                    Thread.sleep(Worker_Delay);
                }
                DDLWarez_Linkgrabbers[i] = new DDLWarez_Linkgrabber(progress, i, br.cloneBrowser());
                DDLWarez_Linkgrabbers[i].setjob(forms[i]);
                DDLWarez_Linkgrabbers[i].start();
            }
            for (int i = 0; i < forms.length; ++i) {
                try {
                    DDLWarez_Linkgrabbers[i].join();
                    if (DDLWarez_Linkgrabbers[i].status() == DDLWarez_Linkgrabber.THREADPASS) {
                        DownloadLink link = createDownloadlink(DDLWarez_Linkgrabbers[i].getlink());
                        link.setSourcePluginPasswords(passwords);
                        decryptedLinks.add(link);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return decryptedLinks;
        } catch (DecrypterException e2) {
            throw e2;
        } catch (Exception e) {
            e.printStackTrace();
            logger.finest("String_Node_Str");
        }
    }
    return null;
}

Output:
                     file = this.getLocalCaptchaFile(this);
-                    Browser.download(file, br.cloneBrowser().openGetConnection("String_Node_Str"));
+                    Browser.download(file, br.cloneBrowser().openGetConnection("String_Node_Str" + br.getHost() + "String_Node_Str" + br.getRegex("String_Node_Str").getMatch(0)));
                     try {


Input:
public int refreshPreferences() {
    prefName = "String_Node_Str" + myExtruderID + "String_Node_Str";
    int result = -1;
    try {
        result = Preferences.loadGlobalInt(prefName + "String_Node_Str");
        maxExtruderSpeed = 255;
        purgeTime = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionPWM = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionTemp = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionSize = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionHeight = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        if (Preferences.loadGlobalDouble(prefName + "String_Node_Str") == -1)
            extrusionInfillWidth = extrusionSize / Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        else
            extrusionInfillWidth = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        lowerFineLayers = 2;
        upperFineLayers = 2;
        extrusionBroadWidth = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        coolingPeriod = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        fastXYFeedrate = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        fastEFeedrate = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        slowXYFeedrate = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        maxAcceleration = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        middleStart = Preferences.loadGlobalBool(prefName + "String_Node_Str");
        t0 = 0;
        iSpeed = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        oSpeed = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        asLength = -1;
        asFactor = 0.5;
        material = Preferences.loadGlobalString(prefName + "String_Node_Str");
        supportMaterial = Preferences.loadGlobalString(prefName + "String_Node_Str");
        inFillMaterial = Preferences.loadGlobalString(prefName + "String_Node_Str");
        offsetX = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        offsetY = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        offsetZ = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        nozzleWipeEnabled = false;
        nozzleWipeDatumX = 22.4;
        nozzleWipeDatumY = 4;
        nozzleWipeStrokeX = 0;
        nozzleWipeStrokeY = 10;
        nozzleWipeFreq = 1;
        nozzleClearTime = 10;
        nozzleWaitTime = 0;
        randSt = false;
        incrementedSt = false;
        shortLength = -1;
        shortSpeed = 1;
        infillOverlap = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionDelayForLayer = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionDelayForPolygon = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionOverRun = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        valveDelayForLayer = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        valveDelayForPolygon = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionReverseDelay = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        valveOverRun = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        minLiftedZ = -1;
        valvePulseTime = 0.5 * Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        shells = Preferences.loadGlobalInt(prefName + "String_Node_Str");
        pauseBetweenSegments = false;
        extrusionFoundationWidth = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrusionLastFoundationWidth = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        separationFraction = 0.8;
        arcCompensationFactor = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        arcShortSides = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        extrudeRatio = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        lift = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        evenHatchDirection = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        oddHatchDirection = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
        Color3f col = new Color3f((float) Preferences.loadGlobalDouble(prefName + "String_Node_Str"), (float) Preferences.loadGlobalDouble(prefName + "String_Node_Str"), (float) Preferences.loadGlobalDouble(prefName + "String_Node_Str"));
        materialColour = new Appearance();
        materialColour.setMaterial(new Material(col, black, col, black, 101f));
    } catch (Exception ex) {
        Debug.e("String_Node_Str" + ex.toString());
    }
    if (printer == null) {
        Debug.e("String_Node_Str");
    } else {
        fastXYFeedrate = Math.min(printer.getFastXYFeedrate(), fastXYFeedrate);
        slowXYFeedrate = Math.min(printer.getSlowXYFeedrate(), slowXYFeedrate);
        maxAcceleration = Math.min(printer.getMaxXYAcceleration(), maxAcceleration);
    }
    return result;
}

Output:
         extrusionHeight = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
-        if (Preferences.loadGlobalDouble(prefName + "String_Node_Str") == -1)
-            extrusionInfillWidth = extrusionSize / Preferences.loadGlobalDouble(prefName + "String_Node_Str");
-        else
-            extrusionInfillWidth = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
+        extrusionInfillWidth = Preferences.loadGlobalDouble(prefName + "String_Node_Str");
         lowerFineLayers = 2;


Input:
public void inputChanged(final Viewer viewer, Object oldInput, final Object newInput) {
    Validate.isTrue(viewer instanceof TreeViewer);
    m_childToParentMap.clear();
    DataEventDispatcher ded = DataEventDispatcher.getInstance();
    if (m_modelListener != null) {
        ded.removeDataChangedListener(m_modelListener);
        m_modelListener = null;
    }
    if (newInput != null) {
        m_modelListener = new IDataChangedListener() {
            public void handleDataChanged(DataChangedEvent... events) {
                for (DataChangedEvent e : events) {
                    handleDataChanged(e.getPo(), e.getDataState(), e.getUpdateState());
                }
            }
            public void handleDataChanged(IPersistentObject po, DataState dataState, UpdateState updateState) {
                if (updateState != UpdateState.notInEditor) {
                    StructuredViewer structuredViewer = (StructuredViewer) viewer;
                    if (dataState == DataState.StructureModified) {
                        boolean objectsAreEqual = structuredViewer.getComparer() != null ? structuredViewer.getComparer().equals(newInput, po) : newInput.equals(po);
                        if (objectsAreEqual || po instanceof IAUTMainPO || po instanceof IObjectMappingPO) {
                            structuredViewer.refresh();
                        } else {
                            structuredViewer.refresh(po);
                        }
                    } else if (dataState == DataState.Renamed) {
                        structuredViewer.update(po, null);
                    }
                }
            }
        };
        ded.addDataChangedListener(m_modelListener, true);
    }
}

Output:
         };
-        ded.addDataChangedListener(m_modelListener, true);
+        ded.addDataChangedListener(m_modelListener, false);
     }


Input:
private Dimension getMinimumSize(int wHint, int hHint, boolean isFix) {
    if (DesignChoiceConstants.DISPLAY_NONE.equals(display)) {
        return ZERO_DIMENSION;
    }
    int rx = recommendSize != null ? recommendSize.width : 0;
    int ry = recommendSize != null ? recommendSize.height : 0;
    rx = getRealRecommendSizeX(rx, wHint);
    if (wHint == -1 && hHint == -1) {
        int maxWidth = calcMaxSegment();
        Dimension dim = super.getMinimumSize(rx == 0 ? maxWidth : rx, -1);
        dim.height = Math.max(dim.height, Math.max(getInsets().getHeight(), ry));
        return dim;
    }
    Dimension dim;
    if (isFix) {
        int tempHint = wHint;
        int maxWidth = calcMaxSegment();
        if (wHint < maxWidth) {
            tempHint = maxWidth;
        }
        dim = super.getMinimumSize(tempHint <= 0 ? -1 : tempHint, hHint);
        return new Dimension(Math.max(dim.width, rx), Math.max(dim.height, ry));
    } else {
        dim = super.getMinimumSize(rx == 0 ? -1 : rx, hHint);
    }
    if (dim.width < wHint) {
        return new Dimension(Math.max(dim.width, rx), Math.max(dim.height, ry));
    }
    dim = super.getMinimumSize(wHint, hHint);
    return new Dimension(Math.max(dim.width, rx), Math.max(dim.height, ry));
}

Output:
         int maxWidth = calcMaxSegment();
-        if (wHint < maxWidth) {
+        if (wHint < maxWidth && !forceWidth) {
             tempHint = maxWidth;


Input:
public RVMField[] finish() {
    RVMField[] result = popularFVs.get(this);
    if (result != null) {
        array = result;
        return result;
    } else {
        adjustLength(cnt);
        popularFVs.put(this, array);
        return array;
    }
}

Output:
 public RVMField[] finish() {
-    RVMField[] result = popularFVs.get(this);
-    if (result != null) {
-        array = result;
-        return result;
-    } else {
-        adjustLength(cnt);
-        popularFVs.put(this, array);
-        return array;
+    synchronized (RVMField.class) {
+        RVMField[] result = popularFVs.get(this);
+        if (result != null) {
+            array = result;
+            return result;
+        } else {
+            adjustLength(cnt);
+            popularFVs.put(this, array);
+            return array;
+        }
     }


Input:
public <T> T get(String key) throws InsufficientCredentialException {
    Entry entry = simpleMap.getEntry(key);
    if (entry == null) {
        if (contextAccessController.isAccessAllowed(key, ContextAccessLevel.READ)) {
            return null;
        }
    } else {
        if (entry != null && (entry.allowAllToRead || contextAccessController.isAccessAllowed(key, ContextAccessLevel.READ))) {
            return entry.getValue();
        }
    }
    throw new InsufficientCredentialException();
}

Output:
         if (entry != null && (entry.allowAllToRead || contextAccessController.isAccessAllowed(key, ContextAccessLevel.READ))) {
-            return entry.getValue();
+            return (T) entry.getValue();
         }


Input:
public void useTransactionTest() throws Exception {
    namespaceClient.create(new NamespaceMeta.Builder().setName(namespace).build());
    Id.DatasetInstance myTableInstance = Id.DatasetInstance.from(namespace, "String_Node_Str");
    dsFramework.addInstance("String_Node_Str", myTableInstance, DatasetProperties.EMPTY);
    final CountDownLatch receivedLatch = new CountDownLatch(1);
    Assert.assertTrue(feedManager.createFeed(FEED1));
    try {
        Cancellable cancellable = notificationService.subscribe(FEED1, new NotificationHandler<String>() {
            private int received = 0;
            public Type getNotificationType() {
                return String.class;
            }
            public void received(final String notification, NotificationContext notificationContext) {
                notificationContext.execute(new TxRunnable() {
                    public void run(DatasetContext context) throws Exception {
                        KeyValueTable table = context.getDataset("String_Node_Str");
                        table.write("String_Node_Str", String.format("String_Node_Str", notification, received++));
                        receivedLatch.countDown();
                    }
                }, TxRetryPolicy.maxRetries(5));
            }
        });
        TimeUnit.MILLISECONDS.sleep(500);
        try {
            notificationService.publish(FEED1, "String_Node_Str");
            Assert.assertTrue(receivedLatch.await(5, TimeUnit.SECONDS));
            final KeyValueTable table = dsFramework.getDataset(myTableInstance, DatasetDefinition.NO_ARGUMENTS, null);
            Assert.assertNotNull(table);
            final TransactionContext txContext = new TransactionContext(txClient, table);
            Tasks.waitFor(true, new Callable<Boolean>() {
                public Boolean call() throws Exception {
                    txContext.start();
                    try {
                        return "String_Node_Str".equals(Bytes.toString(table.read("String_Node_Str")));
                    } finally {
                        txContext.finish();
                    }
                }
            }, 5, TimeUnit.SECONDS, 50, TimeUnit.MILLISECONDS);
        } finally {
            cancellable.cancel();
        }
    } finally {
        dsFramework.deleteInstance(myTableInstance);
        feedManager.deleteFeed(FEED1);
        namespaceClient.delete(namespace);
    }
}

Output:
                 }
-            }, 5, TimeUnit.SECONDS, 50, TimeUnit.MILLISECONDS);
+            }, 5, TimeUnit.SECONDS);
         } finally {


Input:
private void setAction(GithubListClient<List<Issue>> client) {
    client.observable().observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Pair<List<Issue>, Integer>>() {

        public void onCompleted() {
            stopRefresh();
        }
        public void onError(Throwable e) {
            stopRefresh();
            if (getAdapter() == null || getAdapter().getItemCount() == 0) {
                setEmpty(true);
            }
        }
        public void onNext(Pair<List<Issue>, Integer> listIntegerPair) {
            onResponse(listIntegerPair.first);
        }
    });
}

Output:
 private void setAction(GithubListClient<List<Issue>> client) {
-    client.observable().observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Pair<List<Issue>, Integer>>() {
+    client.observable().observeOn(AndroidSchedulers.mainThread()).doOnNext(new Action1<Pair<List<Issue>, Integer>>() {
+        public void call(Pair<List<Issue>, Integer> listIntegerPair) {
+            setPage(listIntegerPair.second);
+        }
+    }).flatMap(new Func1<Pair<List<Issue>, Integer>, Observable<Issue>>() {
+        public Observable<Issue> call(Pair<List<Issue>, Integer> listIntegerPair) {
+            return Observable.from(listIntegerPair.first);
+        }
+    }).filter(new Func1<Issue, Boolean>() {
+        public Boolean call(Issue issue) {
+            return issue.pullRequest == null;
+        }
+    }).toList().subscribe(new Subscriber<List<Issue>>() {


Input:
private void storeIndexes(Id.NamespacedId targetId, MetadataEntry entry) {
    Set<String> indexes = Sets.newHashSet(Arrays.asList(VALUE_SPLIT_PATTERN.split(entry.getValue())));
    indexes.add(entry.getValue());
    for (String index : indexes) {
        indexedTable.put(getIndexPut(targetId, entry.getKey(), entry.getKey() + KEYVALUE_SEPARATOR + index));
        indexedTable.put(getIndexPut(targetId, entry.getKey(), index));
    }
}

Output:
 private void storeIndexes(Id.NamespacedId targetId, MetadataEntry entry) {
-    Set<String> indexes = Sets.newHashSet(Arrays.asList(VALUE_SPLIT_PATTERN.split(entry.getValue())));
-    indexes.add(entry.getValue());
+    Set<String> valueIndexes = new HashSet<>();
+    if (entry.getValue().contains(TAGS_SEPARATOR)) {
+        valueIndexes.addAll(Arrays.asList(TAGS_SEPARATOR_PATTERN.split(entry.getValue())));
+    } else {
+        valueIndexes.add(entry.getValue());
+    }
+    Set<String> indexes = Sets.newHashSet();
+    for (String index : valueIndexes) {
+        indexes.addAll(Arrays.asList(VALUE_SPLIT_PATTERN.split(index)));
+    }
+    indexes.addAll(valueIndexes);
     for (String index : indexes) {


Input:
public static RootPanel get(String id) {
    RootPanel gwt = rootPanels.get(id);
    if (gwt != null) {
        return gwt;
    }
    Element elem = null;
    if (id != null) {
        if (null == (elem = DOM.getElementById(id))) {
            return null;
        }
    }
    if (rootPanels.size() == 0) {
        hookWindowClosing();
    }
    rootPanels.put(id, gwt = new RootPanel(elem));
    return gwt;
}

Output:
 public static RootPanel get(String id) {
-    RootPanel gwt = rootPanels.get(id);
-    if (gwt != null) {
-        return gwt;
+    RootPanel rp = rootPanels.get(id);
+    if (rp != null) {
+        return rp;
     }


Input:
public void addRecipe(Block previousTier) {
    ShapedOreRecipe recipe = null;
    if (blockLevel == ToolHelper.LEVEL_STONE) {
        recipe = new ShapedOreRecipe(new ItemStack(this), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 's', Blocks.STONE, 'c', previousTier, 'p', Blocks.CRAFTING_TABLE });
    } else if (blockLevel == ToolHelper.LEVEL_IRON) {
        recipe = new ShapedOreRecipe(new ItemStack(this), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 's', Items.IRON_INGOT, 'c', previousTier, 'p', Blocks.CRAFTING_TABLE, 'b', Blocks.IRON_BLOCK });
    } else if (blockLevel == ToolHelper.LEVEL_DIAMOND) {
        recipe = new ShapedOreRecipe(new ItemStack(this), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 's', Items.DIAMOND, 'c', previousTier, 'p', Blocks.CRAFTING_TABLE });
    } else {
        recipe = new ShapedOreRecipe(new ItemStack(this), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 's', "String_Node_Str", 'r', previousTier, 'c', Blocks.CHEST, 'p', Blocks.CRAFTING_TABLE });
    }
    GameRegistry.addRecipe(recipe);
}

Output:
     } else {
-        recipe = new ShapedOreRecipe(new ItemStack(this), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 's', "String_Node_Str", 'r', previousTier, 'c', Blocks.CHEST, 'p', Blocks.CRAFTING_TABLE });
+        recipe = new ShapedOreRecipe(new ItemStack(this), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 's', "String_Node_Str", 'r', previousTier, 'c', "String_Node_Str", 'p', Blocks.CRAFTING_TABLE });
     }


Input:
public String getVersion() {
    return "String_Node_Str";
}

Output:
 public String getVersion() {
-    return "String_Node_Str";
+    return Constants.VERSION;
 }


Input:
public boolean validate() {
    cleanWarnings();
    cleanErrors();
    boolean valid = true;
    if (getRole() == null) {
        addError("String_Node_Str");
        valid = false;
    }
    if (getComponent() == null) {
        addError("String_Node_Str");
        valid = false;
    }
    if (!roleReference()) {
        addError("String_Node_Str");
        valid = false;
    }
    if (getComponent() != null && getParent().getParent() != null) {
        if (getComponent().compareTo(getParent().getParent()) == 0) {
            addError("String_Node_Str");
            valid = false;
        }
        if (getParent().getParent() instanceof NCLContext && !((NCLContext) getParent().getParent()).hasNode(getComponent())) {
            addError("String_Node_Str");
            valid = false;
        } else if (getParent().getParent() instanceof NCLBody && !((NCLBody) getParent().getParent()).hasNode(getComponent())) {
            addError("String_Node_Str");
            valid = false;
        } else if (!(getParent().getParent() instanceof NCLContext) || !(getParent().getParent() instanceof NCLBody)) {
            addError("String_Node_Str");
            valid = false;
        }
    }
    if (getInterface() != null && getComponent() != null) {
        if (getComponent() instanceof NCLMedia) {
            if (getInterface() instanceof NCLArea && !((NCLMedia) getComponent()).hasArea((NCLArea) getInterface())) {
                addError("String_Node_Str");
                valid = false;
            } else if (getInterface() instanceof NCLProperty && !((NCLMedia) getComponent()).hasProperty((NCLProperty) getInterface())) {
                addError("String_Node_Str");
                valid = false;
            } else if (!(getInterface() instanceof NCLProperty) && !(getInterface() instanceof NCLArea)) {
                addError("String_Node_Str");
                valid = false;
            }
        } else if (getComponent() instanceof NCLContext) {
            if (getInterface() instanceof NCLPort && !((NCLContext) getComponent()).hasPort((NCLPort) getInterface())) {
                addError("String_Node_Str");
                valid = false;
            } else if (getInterface() instanceof NCLProperty && !((NCLContext) getComponent()).hasProperty((NCLProperty) getInterface())) {
                addError("String_Node_Str");
                valid = false;
            } else if (!(getInterface() instanceof NCLProperty) && !(getInterface() instanceof NCLPort)) {
                addError("String_Node_Str");
                valid = false;
            }
        } else if (getComponent() instanceof NCLSwitch) {
            if (getInterface() instanceof NCLSwitchPort && !((NCLSwitch) getComponent()).hasPort((NCLSwitchPort) getInterface())) {
                addError("String_Node_Str");
                valid = false;
            } else if (!(getInterface() instanceof NCLProperty)) {
                addError("String_Node_Str");
                valid = false;
            }
        } else
            valid = false;
    }
    if (hasBindParam()) {
        for (P param : bindParams) {
            if (!param.getType().equals(NCLParamInstance.BINDPARAM)) {
                addError("String_Node_Str");
                valid = false;
            }
            valid &= param.validate();
            addWarning(param.getWarnings());
            addError(param.getErrors());
        }
    }
    return valid;
}

Output:
     }
-    if (!roleReference()) {
-        addError("String_Node_Str");
-        valid = false;
-    }
-    if (getComponent() != null && getParent().getParent() != null) {
-        if (getComponent().compareTo(getParent().getParent()) == 0) {
+    if (getComponent() != null && getParent() != null && getParent().getParent() != null) {
+        if (getParent().getParent() instanceof NCLNode && getComponent() instanceof NCLNode && getComponent().compareTo(getParent().getParent()) == 0) {
             addError("String_Node_Str");


Input:
public void addListener(int uid) {
    mClientUids.put(uid, 0);
    if (mNavigating) {
        try {
            mBatteryStats.noteStartGps(uid);
        } catch (RemoteException e) {
            Log.w(TAG, "String_Node_Str");
        }
    }
}

Output:
 public void addListener(int uid) {
-    mClientUids.put(uid, 0);
-    if (mNavigating) {
-        try {
-            mBatteryStats.noteStartGps(uid);
-        } catch (RemoteException e) {
-            Log.w(TAG, "String_Node_Str");
+    synchronized (mListeners) {
+        if (mClientUids.indexOfKey(uid) >= 0) {
+            Log.w(TAG, "String_Node_Str" + uid);
+            return;
+        }
+        mClientUids.put(uid, 0);
+        if (mNavigating) {
+            try {
+                mBatteryStats.noteStartGps(uid);
+            } catch (RemoteException e) {
+                Log.w(TAG, "String_Node_Str");
+            }
         }


Input:
private IdentityServiceException handleException(final Exception e) throws IdentityServiceException {
    final IdentityServiceException cause = Exceptions.findCause(e, IdentityServiceException.class);
    if (cause != null) {
        throw cause;
    }
    logger.error(e, e);
    final IdentityServiceException exception = new IdentityServiceReceiverException("String_Node_Str", String.valueOf(e.getMessage()));
    if (Contexts.lookup().hasAdministrativePrivileges()) {
        exception.initCause(e);
    }
    throw exception;
}

Output:
     }
-    logger.error(e, e);
+    AuthException auth = Exceptions.findCause(e, AuthException.class);
+    if (auth == null || !isNotFoundError(auth)) {
+        logger.error(e, e);
+    }
     final IdentityServiceException exception = new IdentityServiceReceiverException("String_Node_Str", String.valueOf(e.getMessage()));


Input:
protected int getHScrollSelectionInPixels() {
    ScrollBar hScrollBar = getHorizontalBar();
    int res = hScrollBar.getSelection() * COLUMN_WIDTH;
    int max = hScrollBar.getMaximum();
    if (max > 1 && hScrollBar.getSelection() >= max - 3) {
        return res + 100;
    }
    return res;
}

Output:
     int max = hScrollBar.getMaximum();
-    if (max > 1 && hScrollBar.getSelection() >= max - 3) {
+    if (max > 3 && hScrollBar.getSelection() >= max - 3) {
         return res + 100;


Input:
private static ContextType getHadoopClusterContextType(DatabaseConnection dbConn, boolean useDefaultContext) {
    ContextType hadoopClusterContextType = null;
    IHadoopClusterService hadoopClusterService = null;
    if (GlobalServiceRegister.getDefault().isServiceRegistered(IHadoopClusterService.class)) {
        hadoopClusterService = (IHadoopClusterService) GlobalServiceRegister.getDefault().getService(IHadoopClusterService.class);
    }
    if (hadoopClusterService != null) {
        ConnectionItem hadoopClusterItem = (ConnectionItem) hadoopClusterService.getHadoopClusterItemById(dbConn.getParameters().get(ConnParameterKeys.CONN_PARA_KEY_HADOOP_CLUSTER_ID));
        if (hadoopClusterItem != null) {
            Connection hadoopClusterConnection = hadoopClusterItem.getConnection();
            hadoopClusterContextType = ConnectionContextHelper.getContextTypeForContextMode(null, hadoopClusterConnection, hadoopClusterConnection.getContextName(), useDefaultContext);
        }
    }
    return hadoopClusterContextType;
}

Output:
     if (hadoopClusterService != null) {
-        ConnectionItem hadoopClusterItem = (ConnectionItem) hadoopClusterService.getHadoopClusterItemById(dbConn.getParameters().get(ConnParameterKeys.CONN_PARA_KEY_HADOOP_CLUSTER_ID));
-        if (hadoopClusterItem != null) {
-            Connection hadoopClusterConnection = hadoopClusterItem.getConnection();
-            hadoopClusterContextType = ConnectionContextHelper.getContextTypeForContextMode(null, hadoopClusterConnection, hadoopClusterConnection.getContextName(), useDefaultContext);
+        EMap<String, String> parameters = dbConn.getParameters();
+        if (parameters != null && parameters.size() > 0) {
+            ConnectionItem hadoopClusterItem = (ConnectionItem) hadoopClusterService.getHadoopClusterItemById(parameters.get(ConnParameterKeys.CONN_PARA_KEY_HADOOP_CLUSTER_ID));
+            if (hadoopClusterItem != null) {
+                Connection hadoopClusterConnection = hadoopClusterItem.getConnection();
+                hadoopClusterContextType = ConnectionContextHelper.getContextTypeForContextMode(null, hadoopClusterConnection, hadoopClusterConnection.getContextName(), useDefaultContext);
+            }
         }


Input:
public String getProcessName() {
    return getProcess().getLabel();
}

Output:
 public String getProcessName() {
-    return getProcess().getLabel();
+    return name;
 }


Input:
public long getLastInvokedAtMillis() {
    return occursInApplications.values().stream().map(ApplicationDescriptor::getInvokedAtMillis).reduce(Math::max).orElse(0L);
}

Output:
 public long getLastInvokedAtMillis() {
-    return occursInApplications.values().stream().map(ApplicationDescriptor::getInvokedAtMillis).reduce(Math::max).orElse(0L);
+    return occursInApplications.stream().map(ApplicationDescriptor::getInvokedAtMillis).reduce(Math::max).orElse(0L);
 }


Input:
public boolean equals(Object other) {
    return (other instanceof Submission && this.getFullName().equals(((Comment) other).getFullName()));
}

Output:
 public boolean equals(Object other) {
-    return (other instanceof Submission && this.getFullName().equals(((Comment) other).getFullName()));
+    return (other instanceof Submission && this.getFullName().equals(((Submission) other).getFullName()));
 }


Input:
public void read(NBTTagCompound nbt) {
    NBTTagList blocksMapping = nbt.getTagList("String_Node_Str", Constants.NBT.TAG_COMPOUND);
    for (int i = 0; i < blocksMapping.tagCount(); ++i) {
        NBTTagCompound sub = blocksMapping.getCompoundTagAt(i);
        String name = sub.getString("String_Node_Str");
        Block b = (Block) Block.blockRegistry.getObject(name);
        if (b != null) {
            registerBlock(b);
        } else {
            idToBlock.add(null);
            BCLog.logger.log(Level.WARN, "String_Node_Str" + name);
        }
    }
    NBTTagList itemsMapping = nbt.getTagList("String_Node_Str", Constants.NBT.TAG_COMPOUND);
    for (int i = 0; i < itemsMapping.tagCount(); ++i) {
        NBTTagCompound sub = itemsMapping.getCompoundTagAt(i);
        String name = sub.getString("String_Node_Str");
        Item item = (Item) Item.itemRegistry.getObject(name);
        if (item != null) {
            registerItem(item);
        } else {
            idToItem.add(null);
            BCLog.logger.log(Level.WARN, "String_Node_Str" + name);
        }
    }
    NBTTagList entitiesMapping = nbt.getTagList("String_Node_Str", Constants.NBT.TAG_COMPOUND);
    for (int i = 0; i < entitiesMapping.tagCount(); ++i) {
        NBTTagCompound sub = entitiesMapping.getCompoundTagAt(i);
        String name = sub.getString("String_Node_Str");
        Class<? extends Entity> e = null;
        try {
            e = (Class<? extends Entity>) Class.forName(name);
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
        if (e != null) {
            registerEntity(e);
        } else {
            idToEntity.add(null);
            BCLog.logger.log(Level.WARN, "String_Node_Str" + name);
        }
    }
}

Output:
         String name = sub.getString("String_Node_Str");
-        Block b = (Block) Block.blockRegistry.getObject(name);
+        Block b = null;
+        if (Block.blockRegistry.containsKey(name)) {
+            b = (Block) Block.blockRegistry.getObject(name);
+        }
         if (b != null) {


Input:
public boolean equals(MOOSEModel otherMooseModel) {
    boolean retVal;
    if (this == otherMooseModel) {
        return true;
    }
    if (otherMooseModel == null || !(otherMooseModel instanceof Item) || !super.equals(otherMooseModel)) {
        return false;
    }
    retVal = (this.allowedActions.equals(otherMooseModel.allowedActions)) && (this.form.equals(otherMooseModel.form)) && (this.itemType == otherMooseModel.itemType) && (this.status.equals(otherMooseModel.status));
    if (this.project != null && otherMooseModel.project != null && (!(this.project.equals(otherMooseModel.project)))) {
        return false;
    }
    if (this.project == null && otherMooseModel.project != null || this.project != null && otherMooseModel.project == null) {
        return false;
    }
    return retVal;
}

Output:
     boolean retVal;
-    if (this == otherMooseModel) {
+    if (this == other) {
         return true;