Input:
public final Unary_expressionContext unary_expression() throws RecognitionException {
    Unary_expressionContext _localctx = new Unary_expressionContext(_ctx, getState());
    enterRule(_localctx, 78, RULE_unary_expression);
    try {
        setState(343);
        switch(_input.LA(1)) {
            case 4:
            case 37:
                enterOuterAlt(_localctx, 1);
                {
                    setState(336);
                    inc_dec();
                    setState(337);
                    cast_expression();
                }
                break;
            case 1:
            case 2:
            case 20:
            case 27:
            case 43:
            case 53:
                enterOuterAlt(_localctx, 2);
                {
                    setState(339);
                    unary_operator();
                    setState(340);
                    cast_expression();
                }
                break;
            case 28:
            case ALPHA_NUMERIC:
            case HEX_LITERAL:
            case DECIMAL_LITERAL:
            case OCTAL_LITERAL:
            case FLOATING_POINT_LITERAL:
            case CHAR:
            case STRING:
                enterOuterAlt(_localctx, 3);
                {
                    setState(342);
                    postfix_expression(0);
                }
                break;
            default:
                throw new NoViableAltException(this);
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

Output:
     try {
-        setState(343);
-        switch(_input.LA(1)) {
-            case 4:
-            case 37:
+        setState(356);
+        switch(getInterpreter().adaptivePredict(_input, 22, _ctx)) {
+            case 1:
                 enterOuterAlt(_localctx, 1);


Input:
public void delegateSpawn(PartitionContext partitionContext, String clusterId) {
    try {
        String nwPartitionId = partitionContext.getNetworkPartitionId();
        NetworkPartitionContext ctxt = PartitionManager.getInstance().getNetworkPartition(nwPartitionId);
        Properties props = partitionContext.getProperties();
        String value = (String) props.get(org.apache.stratos.messaging.util.Constants.LOAD_BALANCER_REF);
        String lbClusterId;
        if (value.equals(org.apache.stratos.messaging.util.Constants.DEFAULT_LOAD_BALANCER)) {
            lbClusterId = ctxt.getDefaultLbClusterId();
        } else if (value.equals(org.apache.stratos.messaging.util.Constants.SERVICE_AWARE_LOAD_BALANCER)) {
            String serviceName = partitionContext.getServiceName();
            lbClusterId = ctxt.getLBClusterIdOfService(serviceName);
        }
        MemberContext memberContext = CloudControllerClient.getInstance().spawnAnInstance(partitionContext.getPartition(), clusterId, lbClusterId);
        if (memberContext != null) {
            partitionContext.addPendingMember(memberContext);
        }
    } catch (Throwable e) {
        String message = "String_Node_Str";
        log.error(message, e);
        throw new RuntimeException(message, e);
    }
}

Output:
         String value = (String) props.get(org.apache.stratos.messaging.util.Constants.LOAD_BALANCER_REF);
-        String lbClusterId;
+        String lbClusterId = null;
         if (value.equals(org.apache.stratos.messaging.util.Constants.DEFAULT_LOAD_BALANCER)) {


Input:
public List<IBrowserConf> getBrowserListForSheet(IMappingData data) {
    IMappingData methodData = data;
    List<IBrowserConf> browserConfList = new ArrayList<IBrowserConf>();
    URL browserSheetURL;
    String sheetNameHolder = null;
    ListFeed browserFeed;
    for (String browserSheet : methodData.getClientEnvironment()) {
        sheetNameHolder = browserSheet;
        try {
            browserSheetURL = getWorkSheet(browserSheet).getListFeedUrl();
            browserFeed = service.getFeed(browserSheetURL, ListFeed.class);
            for (ListEntry row : browserFeed.getEntries()) {
                browserConfList.add(getBrowserConfFromRow(row));
            }
        } catch (NullPointerException ex) {
            System.out.println("String_Node_Str" + sheetNameHolder);
            LOGGER.error(ex);
        } catch (IOException e) {
            LOGGER.error(e);
        } catch (ServiceException e) {
            LOGGER.error(e);
        }
    }
    return browserConfList;
}

Output:
         } catch (NullPointerException ex) {
-            System.out.println("String_Node_Str" + sheetNameHolder);
+            LOGGER.error("String_Node_Str" + sheetNameHolder);
             LOGGER.error(ex);


Input:
private void pushSubprotocolSignature(ProtocolName fullname, List<Role> roleargs, List<Argument<? extends Kind>> argargs) {
    Map<Role, RoleNode> rolemap = rolemaps.peek();
    Map<Argument<? extends Kind>, ArgumentNode> argmap = argmaps.peek();
    List<Role> roles = new LinkedList<>(roleargs);
    List<Argument<? extends Kind>> args = new LinkedList<>(argargs);
    SubprotocolSignature ssubsig = new SubprotocolSignature(fullname, getScope(), roles, args);
    this.stack.add(ssubsig);
}

Output:
     List<Argument<? extends Kind>> args = new LinkedList<>(argargs);
-    SubprotocolSignature ssubsig = new SubprotocolSignature(fullname, getScope(), roles, args);
+    SubprotocolSignature ssubsig = new SubprotocolSignature(fullname, roles, args);
     this.stack.add(ssubsig);


Input:
public static DesfireFileSettings selectAppFile(DesfireProtocol tag, int appID, int fileID) {
    try {
        tag.selectApp(appID);
    } catch (DesfireException e) {
        System.out.println("String_Node_Str");
        return null;
    }
    try {
        return tag.getFileSettings(1);
    } catch (DesfireException e) {
        System.out.println("String_Node_Str");
        return null;
    }
}

Output:
     try {
-        return tag.getFileSettings(1);
+        return tag.getFileSettings(fileID);
     } catch (DesfireException e) {


Input:
public static void outputXmlDocument(Node node, StreamResult output, Properties outputProperties) throws TransformerException {
    Transformer transformer = TransformerFactory.newInstance().newTransformer();
    transformer.setOutputProperties(outputProperties);
    transformer.transform(new DOMSource(node), output);
}

Output:
     transformer.setOutputProperties(outputProperties);
-    transformer.transform(new DOMSource(node), output);
+    transformer.transform(new DOMSource(node), new StreamResult(output));
 }


Input:
private void updateEmptyMessageUIStates() {
    boolean bEnabled = getChart().getEmptyMessage().isSetVisible() && getChart().getEmptyMessage().isVisible();
    txtEmptyMsg.setEnabled(bEnabled);
    fdcEmptyMsg.setEnabled(bEnabled);
    lbTxtEmptyMsg.setEnabled(bEnabled);
    lbFdcEmptyMsg.setEnabled(bEnabled);
}

Output:
 private void updateEmptyMessageUIStates() {
-    boolean bEnabled = getChart().getEmptyMessage().isSetVisible() && getChart().getEmptyMessage().isVisible();
+    boolean bEnabled = !ChartUIExtensionUtil.isSetInvisible(getChart().getEmptyMessage());
     txtEmptyMsg.setEnabled(bEnabled);


Input:
public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
    if (!world.isRemote) {
        MovingObjectPosition mop = this.getMovingObjectPositionFromPlayer(world, player, false);
        if (mop == null || !mop.typeOfHit.equals(MovingObjectType.BLOCK)) {
            int offset = this.getCharge(stack) + 3;
            CoordinateBox box = new CoordinateBox(player.posX - offset, player.posY - offset, player.posZ - offset, player.posX + offset, player.posY + offset, player.posZ + offset);
            List<ItemStack> drops = new ArrayList<ItemStack>();
            for (int x = (int) box.minX; x <= box.maxX; x++) for (int y = (int) box.minY; y <= box.maxY; y++) for (int z = (int) box.minZ; z <= box.maxZ; z++) {
                Block block = world.getBlock(x, y, z);
                if (Utils.isOre(block) && block.getBlockHardness(world, x, y, z) != -1 && canHarvestBlock(block, stack)) {
                    Utils.harvestVein(world, player, stack, new Coordinates(x, y, z), block, drops, 0);
                }
            }
            if (!drops.isEmpty()) {
                world.spawnEntityInWorld(new EntityLootBall(world, drops, player.posX, player.posY, player.posZ));
                PacketHandler.sendTo(new SwingItemPKT(), (EntityPlayerMP) player);
            }
            return stack;
        }
        Block block = world.getBlock(mop.blockX, mop.blockY, mop.blockZ);
        List<ItemStack> drops = new ArrayList<ItemStack>();
        if (Utils.isOre(block) || block.equals(Blocks.gravel)) {
            Utils.harvestVein(world, player, stack, new Coordinates(mop), block, drops, 0);
        } else if (block.getHarvestTool(0) == null || block.getHarvestTool(0).equals("String_Node_Str")) {
            CoordinateBox box = getRelativeBox(new Coordinates(mop), ForgeDirection.getOrientation(mop.sideHit), this.getCharge(stack) + 1);
            byte charge = this.getCharge(stack);
            for (int x = (int) box.minX; x <= box.maxX; x++) for (int y = (int) box.minY; y <= box.maxY; y++) for (int z = (int) box.minZ; z <= box.maxZ; z++) {
                Block b = world.getBlock(x, y, z);
                if (b != Blocks.air && b.getBlockHardness(world, x, y, z) != -1 && canHarvestBlock(b, stack)) {
                    drops.addAll(Utils.getBlockDrops(world, player, b, stack, x, y, z));
                    world.setBlockToAir(x, y, z);
                }
            }
        }
        if (!drops.isEmpty()) {
            world.spawnEntityInWorld(new EntityLootBall(world, drops, player.posX, player.posY, player.posZ));
            PacketHandler.sendTo(new SwingItemPKT(), (EntityPlayerMP) player);
        }
    }
    return stack;
}

Output:
 public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
-    if (!world.isRemote) {
+    if (!world.isRemote && this.getCharge(stack) != 0) {
         MovingObjectPosition mop = this.getMovingObjectPositionFromPlayer(world, player, false);


Input:
private GUIEvent updateMouse(View component, PointerEvent event) {
    if (!component.isVisible()) {
        return GUIEvent.NONE;
    }
    if (component.onMouse(event)) {
        if (!component.isMouseOver()) {
            component.setMouseOver(true);
            setMouseOver(component);
        }
    } else {
        if (component.isMouseOver()) {
            component.setMouseOver(false);
            resetMouseOver();
        }
    }
    GUIEvent result = component.updateMouse(event);
    if (result != GUIEvent.NONE && result != null) {
        updateEvent(component, result);
        return result;
    }
    for (View child : component.getViews()) {
        child.setOffset(component.getX(), component.getY());
        updateMouse(child, event);
        child.setOffset(-component.getX(), -component.getY());
    }
    return GUIEvent.NONE;
}

Output:
     }
-    if (component.onMouse(event)) {
-        if (!component.isMouseOver()) {
-            component.setMouseOver(true);
+    if (component.isMouseOver()) {
+        if (component != mouseOver) {
             setMouseOver(component);


Input:
public void execute() throws MojoExecutionException, MojoFailureException {
    getLog().info(MavenUtils.LOG_SEPARATOR);
    String shouldRunProperty = System.getProperty(Migrator.SHOULD_RUN_SYSTEM_PROPERTY);
    if (shouldRunProperty != null && !Boolean.valueOf(shouldRunProperty).booleanValue()) {
        getLog().warn("String_Node_Str" + Migrator.SHOULD_RUN_SYSTEM_PROPERTY + "String_Node_Str");
        return;
    }
    ClassLoader artifactClassLoader = getMavenArtifactClassLoader();
    configureFieldsAndValues(getFileOpener(artifactClassLoader));
    displayMojoSettings();
    checkRequiredParametersAreSpecified();
    Connection connection = null;
    try {
        connection = MavenUtils.getDatabaseConnection(artifactClassLoader, driver, url, username, password);
        Migrator migrator = createMigrator(getFileOpener(artifactClassLoader));
        configureMigrator(migrator, connection);
        getLog().info("String_Node_Str" + url);
        if (promptOnNonLocalDatabase && !migrator.isSafeToRunMigration()) {
            if (migrator.swingPromptForNonLocalDatabase()) {
                throw new LiquibaseException("String_Node_Str");
            }
        }
        performLiquibaseTask(migrator);
    } catch (LiquibaseException e) {
        releaseConnection(connection);
        throw new MojoFailureException(e.getMessage());
    }
    releaseConnection(connection);
    getLog().info(MavenUtils.LOG_SEPARATOR);
    getLog().info("String_Node_Str");
}

Output:
         getLog().info("String_Node_Str" + url);
-        if (promptOnNonLocalDatabase && !migrator.isSafeToRunMigration()) {
+        if (isPromptOnNonLocalDatabase() && !migrator.isSafeToRunMigration()) {
             if (migrator.swingPromptForNonLocalDatabase()) {


Input:
public void testPBES2ConformanceTestDesEde3() throws Exception {
    byte[] data = Base64.decode("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
    testPBES2Conformance("String_Node_Str", "String_Node_Str", -1, "String_Node_Str", data);
}

Output:
     byte[] data = Base64.decode("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
-    testPBES2Conformance("String_Node_Str", "String_Node_Str", -1, "String_Node_Str", data);
+    runTestPBES2Conformance("String_Node_Str", "String_Node_Str", -1, "String_Node_Str", data);
 }


Input:
public String getLocalizedFormatCode() {
    if (UNFORMATTED.equals(formatPattern) || DATETIME_UNFORMATTED.equals(formatPattern) || DATE_UNFORMATTED.equals(formatPattern) || TIME_UNFORMATTED.equals(formatPattern)) {
        return "String_Node_Str";
    }
    SimpleDateFormat dateFormat = getFormatter();
    return dateFormat.toLocalizedPattern();
}

Output:
     if (UNFORMATTED.equals(formatPattern) || DATETIME_UNFORMATTED.equals(formatPattern) || DATE_UNFORMATTED.equals(formatPattern) || TIME_UNFORMATTED.equals(formatPattern)) {
-        return "String_Node_Str";
+        return ((SimpleDateFormat) dateFormat).toLocalizedPattern();
     }


Input:
public static List<String> parseAcceptableLanguages(final String headerValue) throws BatchException {
    List<String> acceptLanguages = new LinkedList<String>();
    TreeSet<Accept> acceptTree = getAcceptTree();
    Scanner acceptLanguageScanner = new Scanner(headerValue);
    acceptLanguageScanner.useDelimiter("String_Node_Str");
    while (acceptLanguageScanner.hasNext()) {
        if (acceptLanguageScanner.hasNext(REG_EX_ACCEPT_LANGUAGES_WITH_Q_FACTOR)) {
            acceptLanguageScanner.next(REG_EX_ACCEPT_LANGUAGES_WITH_Q_FACTOR);
            MatchResult result = acceptLanguageScanner.match();
            if (result.groupCount() == 2) {
                String languagerange = result.group(1);
                double qualityFactor = result.group(2) != null ? Double.parseDouble(result.group(2)) : 1d;
                acceptTree.add(new Accept().setQuality(qualityFactor).setValue(languagerange));
            } else {
                String acceptLanguage = acceptLanguageScanner.next();
                acceptLanguageScanner.close();
                throw new BatchException(BatchException.INVALID_ACCEPT_LANGUAGE_HEADER.addContent(acceptLanguage), BAD_REQUEST);
            }
        } else {
            String acceptLanguage = acceptLanguageScanner.next();
            acceptLanguageScanner.close();
            throw new BatchException(BatchException.INVALID_ACCEPT_LANGUAGE_HEADER.addContent(acceptLanguage), BAD_REQUEST);
        }
    }
    for (Accept accept : acceptTree) {
        acceptLanguages.add(accept.getValue());
    }
    acceptLanguageScanner.close();
    return acceptLanguages;
}

Output:
     for (Accept accept : acceptTree) {
-        acceptLanguages.add(accept.getValue());
+        if (!acceptLanguages.contains(accept.getValue())) {
+            acceptLanguages.add(accept.getValue());
+        }
     }


Input:
public void testReverse() {
    List a = createSortedList();
    Collections.reverse(a);
    Object[] x = { "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    assertEquals(x, a);
    List b = createRandomList();
    Collections.reverse(b);
    Collections.reverse(b);
    assertEquals(b, createRandomList());
}

Output:
 public void testReverse() {
-    List a = createSortedList();
+    List<String> a = createSortedList();
     Collections.reverse(a);


Input:
public void topicRemoved(Topic t) throws TopicMapException {
    if (topicMapListeners.size() > 0) {
        LayeredTopic lt = makeLayeredTopic(t);
        for (TopicMapListener listener : topicMapListeners) {
            listener.topicRemoved(lt);
        }
    }
    removeTopicFromIndex(t.getOneSubjectIdentifier());
}

Output:
 public void topicRemoved(Topic t) throws TopicMapException {
-    if (topicMapListeners.size() > 0) {
+    if (!topicMapListeners.isEmpty()) {
         LayeredTopic lt = makeLayeredTopic(t);


Input:
public void reset() {
    if (reader != null) {
        dispose();
    }
    try {
        reader = new OggReader(stream.openStream());
    } catch (IOException e) {
        throw new RuntimeException("String_Node_Str", e);
    }
}

Output:
     try {
-        reader = new OggReader(stream.openStream());
-    } catch (IOException e) {
+        reader = AccessController.doPrivileged((PrivilegedExceptionAction<OggReader>) () -> new OggReader(stream.openStream()));
+    } catch (PrivilegedActionException e) {
         throw new RuntimeException("String_Node_Str", e);


Input:
public static String getMediaFileName(File mediaFile, String mimeType) {
    String originalFileName = mediaFile.getName().toLowerCase();
    String extension = MimeTypeMap.getFileExtensionFromUrl(originalFileName);
    if (!TextUtils.isEmpty(extension))
        return originalFileName;
    if (!TextUtils.isEmpty(mimeType)) {
        String fileExtension = getExtensionForMimeType(mimeType);
        if (!TextUtils.isEmpty(fileExtension)) {
            originalFileName += "String_Node_Str" + fileExtension;
        }
    } else {
        AppLog.e(AppLog.T.API, "String_Node_Str" + mediaFile.getPath());
    }
    return originalFileName;
}

Output:
 public static String getMediaFileName(File mediaFile, String mimeType) {
-    String originalFileName = mediaFile.getName().toLowerCase();
+    String originalFileName = mediaFile.getName().toLowerCase(Locale.ROOT);
     String extension = MimeTypeMap.getFileExtensionFromUrl(originalFileName);


Input:
private Object tokenToNumber() {
    Token t = token();
    String nStr = token().str;
    int base = 10;
    if (nStr.contains("String_Node_Str")) {
        base = 16;
        nStr = nStr.substring(2);
    } else if (nStr.contains("String_Node_Str")) {
        base = 2;
        nStr = nStr.substring(2);
    }
    int len = nStr.length();
    if (nStr.equals("String_Node_Str")) {
        return Double.NaN;
    }
    if (nStr.equals("String_Node_Str")) {
        return Double.POSITIVE_INFINITY;
    }
    if (t.type == T_TYPE.NUMBER_DOUBLE || t.type == T_TYPE.NUMBER_FLOAT) {
        try {
            if (t.type == T_TYPE.NUMBER_FLOAT) {
                return Float.parseFloat(nStr.substring(0, len - 1));
            }
            return Double.parseDouble(nStr);
        } catch (NumberFormatException e) {
            return new BigDecimal(nStr);
        }
    }
    if (t.type == T_TYPE.NUMBER_INT || t.type == T_TYPE.NUMBER_LONG) {
        try {
            if (t.type == T_TYPE.NUMBER_INT) {
                return Integer.parseInt(nStr, base);
            }
            return Long.parseLong(nStr.substring(0, len - 1), base);
        } catch (NumberFormatException e) {
            return new BigInteger(nStr);
        }
    }
    throw new IllegalArgumentException(token().type.name());
}

Output:
         } catch (NumberFormatException e) {
-            return new BigInteger(nStr);
+            try {
+                return new BigInteger(nStr, base);
+            } catch (NumberFormatException e2) {
+                throw DBLogger.newUser("String_Node_Str" + t.str);
+            }
         }


Input:
Object parseObject(final Element element) throws ParseException {
    Object value = parseCoordinateReferenceSystem(element, false);
    if (value != null) {
        return value;
    }
    value = parseMathTransform(element, false);
    if (value != null) {
        return value;
    }
    String keyword = WKTKeywords.GeogCS;
    final Object child = element.peek();
    if (child instanceof Element) {
        keyword = ((Element) child).keyword;
        if (keyword != null) {
            if (keyword.equalsIgnoreCase(WKTKeywords.Axis))
                return parseAxis(element, SI.METRE, true);
            if (keyword.equalsIgnoreCase(WKTKeywords.PrimeM))
                return parsePrimem(element, NonSI.DEGREE_ANGLE);
            if (keyword.equalsIgnoreCase(WKTKeywords.ToWGS84))
                return parseToWGS84(element);
            if (keyword.equalsIgnoreCase(WKTKeywords.Spheroid))
                return parseSpheroid(element);
            if (keyword.equalsIgnoreCase(WKTKeywords.Vert_Datum))
                return parseVertDatum(element);
            if (keyword.equalsIgnoreCase(WKTKeywords.Local_Datum))
                return parseLocalDatum(element);
            if (keyword.equalsIgnoreCase(WKTKeywords.Datum))
                return parseDatum(element, referencing.getGreenwich());
        }
    }
    throw element.keywordNotFound(keyword, keyword == WKTKeywords.GeogCS);
}

Output:
             if (keyword.equalsIgnoreCase(WKTKeywords.Axis))
-                return parseAxis(element, SI.METRE, true);
+                return parseAxis(element, false, SI.METRE, true);
             if (keyword.equalsIgnoreCase(WKTKeywords.PrimeM))


Input:
public static boolean isLessThanUnsigned(long n1, long n2) {
    return (n1 < n2) ^ ((n1 < 0) != (n2 < 0));
}

Output:
 public static boolean isLessThanUnsigned(long n1, long n2) {
-    return (n1 < n2) ^ ((n1 < 0) != (n2 < 0));
+    return UnsignedLongs.compare(n1, n2) < 0;
 }


Input:
public void testProjectMode() throws Exception {
    OFExport ofExport = new OFExport();
    ofExport.getProjectRoot().add(f1);
    ofExport.setFormat("String_Node_Str");
    ofExport.process();
    StringWriter out = new StringWriter();
    ofExport.write(out);
    Diff.diff(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }, out.toString().split("String_Node_Str"));
}

Output:
     ofExport.write(out);
-    Diff.diff(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }, out.toString().split("String_Node_Str"));
+    Diff.diff(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }, out.toString().split("String_Node_Str"));
 }


Input:
public LogTableColumn deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
    LogTableColumn column = null;
    column = new LogTableColumn();
    JsonObject object = jsonElement.getAsJsonObject();
    column.setIdentifier(object.get("String_Node_Str").getAsInt());
    column.setName(object.get("String_Node_Str").getAsString());
    column.setEnabled(object.get("String_Node_Str").getAsBoolean());
    column.setDefaultVisibleName(object.get("String_Node_Str").getAsString());
    column.setVisibleName(object.get("String_Node_Str").getAsString());
    column.setWidth(object.get("String_Node_Str").getAsInt());
    column.setType(object.get("String_Node_Str").getAsString());
    column.setReadonly(object.get("String_Node_Str").getAsBoolean());
    column.setOrder(object.get("String_Node_Str").getAsInt());
    column.setVisible(object.get("String_Node_Str").getAsBoolean());
    column.setDescription(object.get("String_Node_Str").getAsString());
    column.setIsRegEx(object.get("String_Node_Str").getAsBoolean());
    LogTableColumn.RegExData regExData = new LogTableColumn.RegExData();
    regExData.setRegExString(object.getAsJsonObject("String_Node_Str").get("String_Node_Str").getAsString());
    regExData.setRegExCaseSensitive(object.getAsJsonObject("String_Node_Str").get("String_Node_Str").getAsBoolean());
    column.setRegExData(regExData);
    return column;
}

Output:
     LogTableColumn.RegExData regExData = new LogTableColumn.RegExData();
-    regExData.setRegExString(object.getAsJsonObject("String_Node_Str").get("String_Node_Str").getAsString());
-    regExData.setRegExCaseSensitive(object.getAsJsonObject("String_Node_Str").get("String_Node_Str").getAsBoolean());
+    regExData.setRegExString(object.get("String_Node_Str").getAsString());
+    regExData.setRegExCaseSensitive(object.get("String_Node_Str").getAsBoolean());
     column.setRegExData(regExData);


Input:
public Annotation copy() {
    Annotation cloned = this.deepCopy();
    return cloned;
}

Output:
 public Annotation copy() {
-    Annotation cloned = this.deepCopy();
-    return cloned;
+    return this.deepCopy();
 }


Input:
public DotNetTypeRef toTypeRefWithoutCaching(ResolveToKind kind, boolean resolveFromParent) {
    ResolveResult[] resolveResults = multiResolveImpl(kind, resolveFromParent);
    if (resolveResults.length == 0) {
        return DotNetTypeRef.ERROR_TYPE;
    }
    ResolveResult resolveResult = resolveResults[0];
    if (!resolveResult.isValidResult()) {
        return DotNetTypeRef.ERROR_TYPE;
    }
    return toTypeRef(resolveResult);
}

Output:
     }
-    ResolveResult resolveResult = resolveResults[0];
-    if (!resolveResult.isValidResult()) {
+    ResolveResult firstValidResult = CSharpResolveUtil.findFirstValidResult(resolveResults);
+    if (firstValidResult == null) {
         return DotNetTypeRef.ERROR_TYPE;


Input:
public void closeHandles(Path path) {
    try {
        ProcessBuilder pb = new ProcessBuilder("String_Node_Str", path.toString());
        Process pr = pb.start();
        BufferedReader input = new BufferedReader(new InputStreamReader(pr.getInputStream()));
        String line;
        int count = 0;
        while ((line = input.readLine()) != null) {
            if (count > 4) {
                String[] columns = line.split("String_Node_Str");
                if (columns.length == 4) {
                    log.info("String_Node_Str" + columns[3] + "String_Node_Str" + columns[0]);
                    closeHandle(columns[1], columns[2]);
                } else {
                    log.info("String_Node_Str" + line);
                }
            }
            count++;
        }
        pr.waitFor();
    } catch (InterruptedException | IOException e) {
        log.log(Level.INFO, "String_Node_Str", e);
    }
}

Output:
         Process pr = pb.start();
-        BufferedReader input = new BufferedReader(new InputStreamReader(pr.getInputStream()));
-        String line;
-        int count = 0;
-        while ((line = input.readLine()) != null) {
-            if (count > 4) {
-                String[] columns = line.split("String_Node_Str");
-                if (columns.length == 4) {
-                    log.info("String_Node_Str" + columns[3] + "String_Node_Str" + columns[0]);
-                    closeHandle(columns[1], columns[2]);
-                } else {
-                    log.info("String_Node_Str" + line);
+        try (BufferedReader input = newProcessReader(pr)) {
+            String line;
+            int count = 0;
+            while ((line = input.readLine()) != null) {
+                if (count > 4) {
+                    String[] columns = line.split("String_Node_Str");
+                    if (columns.length == 4) {
+                        log.info("String_Node_Str" + columns[3] + "String_Node_Str" + columns[0]);
+                        closeHandle(columns[1], columns[2]);
+                    } else {
+                        log.info("String_Node_Str" + line);
+                    }
                 }


Input:
public synchronized JiraClient<List<Object>> getClient() {
    if (client == null) {
        client = JiraClientFactory.getClient(address);
    }
    return client;
}

Output:
     if (client == null) {
-        client = JiraClientFactory.getClient(address);
+        setClient(JiraClientFactory.getClient(address));
     }


Input:
private static TournamentType loadTournamentType(GamePlugin plugin) {
    try {
        classLoader.addURL(new File(pluginFolder, plugin.getJar()).toURI().toURL());
        logger.debug("String_Node_Str" + plugin.getClassName());
        return (TournamentType) Class.forName(plugin.getTypeName(), true, classLoader).newInstance();
    } catch (ClassNotFoundException ex) {
        logger.warn("String_Node_Str" + plugin.getName() + "String_Node_Str" + plugin.getJar() + "String_Node_Str", ex);
    } catch (Exception ex) {
        logger.fatal("String_Node_Str" + plugin.getJar(), ex);
    }
    return null;
}

Output:
         logger.debug("String_Node_Str" + plugin.getClassName());
-        return (TournamentType) Class.forName(plugin.getTypeName(), true, classLoader).newInstance();
+        return (TournamentType) Class.forName(plugin.getTypeName(), true, classLoader).getConstructor().newInstance();
     } catch (ClassNotFoundException ex) {


Input:
protected Object decode(Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
    ChannelBuffer buf = (ChannelBuffer) msg;
    buf.skipBytes(buf.getUnsignedByte(buf.readerIndex() + 3));
    List<Position> positions = new LinkedList<>();
    while (buf.readableBytes() > 2) {
        int length = buf.readUnsignedShort();
        int index = buf.readUnsignedShort();
        int recordFlags = buf.readUnsignedByte();
        if (BitUtil.check(recordFlags, 0)) {
            buf.readUnsignedInt();
        }
        if (BitUtil.check(recordFlags, 1)) {
            buf.readUnsignedInt();
        }
        if (BitUtil.check(recordFlags, 2)) {
            buf.readUnsignedInt();
        }
        int serviceType = buf.readUnsignedByte();
        buf.readUnsignedByte();
        int recordEnd = buf.readerIndex() + length;
        Position position = new Position(getProtocolName());
        DeviceSession deviceSession = getDeviceSession(channel, remoteAddress);
        if (deviceSession != null) {
            position.setDeviceId(deviceSession.getDeviceId());
        }
        ChannelBuffer response = ChannelBuffers.dynamicBuffer(ByteOrder.LITTLE_ENDIAN, 0);
        response.writeShort(index);
        response.writeByte(0);
        sendResponse(channel, PT_RESPONSE, index, serviceType, MSG_RECORD_RESPONSE, response);
        while (buf.readerIndex() < recordEnd) {
            int type = buf.readUnsignedByte();
            int end = buf.readUnsignedShort() + buf.readerIndex();
            if (type == MSG_TERM_IDENTITY) {
                buf.readUnsignedInt();
                int flags = buf.readUnsignedByte();
                if (BitUtil.check(flags, 0)) {
                    buf.readUnsignedShort();
                }
                if (BitUtil.check(flags, 1)) {
                    getDeviceSession(channel, remoteAddress, buf.readBytes(15).toString(StandardCharsets.US_ASCII));
                }
                if (BitUtil.check(flags, 2)) {
                    getDeviceSession(channel, remoteAddress, buf.readBytes(16).toString(StandardCharsets.US_ASCII));
                }
                if (BitUtil.check(flags, 3)) {
                    buf.skipBytes(3);
                }
                if (BitUtil.check(flags, 5)) {
                    buf.skipBytes(3);
                }
                if (BitUtil.check(flags, 6)) {
                    buf.readUnsignedShort();
                }
                if (BitUtil.check(flags, 7)) {
                    getDeviceSession(channel, remoteAddress, buf.readBytes(15).toString(StandardCharsets.US_ASCII));
                }
                response = ChannelBuffers.dynamicBuffer(ByteOrder.LITTLE_ENDIAN, 0);
                response.writeByte(0);
                sendResponse(channel, PT_APPDATA, index, serviceType, MSG_RESULT_CODE, response);
            } else if (type == MSG_POS_DATA) {
                position.setTime(new Date((buf.readUnsignedInt() + 1262304000) * 1000));
                position.setLatitude(buf.readUnsignedInt() * 90.0 / 0xFFFFFFFFL);
                position.setLongitude(buf.readUnsignedInt() * 180.0 / 0xFFFFFFFFL);
                int flags = buf.readUnsignedByte();
                position.setValid(BitUtil.check(flags, 0));
                if (BitUtil.check(flags, 5)) {
                    position.setLatitude(-position.getLatitude());
                }
                if (BitUtil.check(flags, 6)) {
                    position.setLongitude(-position.getLongitude());
                }
                int speed = buf.readUnsignedShort();
                position.setSpeed(BitUtil.to(speed, 14));
                position.setCourse(buf.readUnsignedByte() + (BitUtil.check(speed, 15) ? 0x100 : 0));
                position.set(Position.KEY_ODOMETER, buf.readUnsignedMedium() * 100);
                position.set(Position.KEY_INPUT, buf.readUnsignedByte());
                position.set(Position.KEY_EVENT, buf.readUnsignedByte());
                if (BitUtil.check(flags, 7)) {
                    position.setAltitude(buf.readMedium());
                }
            } else if (type == MSG_EXT_POS_DATA) {
                int flags = buf.readUnsignedByte();
                if (BitUtil.check(flags, 0)) {
                    position.set(Position.KEY_VDOP, buf.readUnsignedShort());
                }
                if (BitUtil.check(flags, 1)) {
                    position.set(Position.KEY_HDOP, buf.readUnsignedShort());
                }
                if (BitUtil.check(flags, 2)) {
                    position.set(Position.KEY_PDOP, buf.readUnsignedShort());
                }
                if (BitUtil.check(flags, 3)) {
                    position.set(Position.KEY_SATELLITES, buf.readUnsignedByte());
                }
            } else if (type == MSG_AD_SENSORS_DATA) {
                buf.readUnsignedByte();
                position.set(Position.KEY_OUTPUT, buf.readUnsignedByte());
                buf.readUnsignedByte();
            }
            buf.readerIndex(end);
        }
        if (deviceSession != null) {
            positions.add(position);
        }
    }
    return positions.isEmpty() ? null : positions;
}

Output:
                 if (BitUtil.check(flags, 1)) {
-                    getDeviceSession(channel, remoteAddress, buf.readBytes(15).toString(StandardCharsets.US_ASCII));
+                    getDeviceSession(channel, remoteAddress, buf.readBytes(15).toString(StandardCharsets.US_ASCII).trim());
                 }


Input:
public static EventHandlerChain<CreateListenerEvent> onCreateListener() {
    if (onCreateListenerChain == null) {
        onCreateListenerChain = (new EventHandlerChainNewListeners()).build();
    }
    return onCreateListenerChain;
}

Output:
 public static EventHandlerChain<CreateListenerEvent> onCreateListener() {
-    if (onCreateListenerChain == null) {
-        onCreateListenerChain = (new EventHandlerChainNewListeners()).build();
-    }
-    return onCreateListenerChain;
+    return (new EventHandlerChainNewListeners()).build();
 }


Input:
public static List validateBinding(ICubeQueryDefinition queryDefn, boolean suppressException) throws DataException {
    List result = new ArrayList();
    Set validDimLevels = new HashSet();
    populateLevel(queryDefn, validDimLevels, ICubeQueryDefinition.COLUMN_EDGE);
    populateLevel(queryDefn, validDimLevels, ICubeQueryDefinition.ROW_EDGE);
    for (int i = 0; i < queryDefn.getBindings().size(); i++) {
        boolean isValid = true;
        IBinding binding = (IBinding) queryDefn.getBindings().get(i);
        if (binding.getAggrFunction() != null && binding.getExpression() instanceof IScriptExpression) {
            String expr = ((IScriptExpression) binding.getExpression()).getText();
            if (expr == null && (AggregationFactory.getInstance().getAggrInfo(binding.getAggrFunction()) != null && !AggregationFactory.getInstance().getAggrInfo(binding.getAggrFunction()).needDataField()))
                continue;
        }
        Set levels = OlapExpressionCompiler.getReferencedDimLevel(binding.getExpression(), queryDefn.getBindings());
        if (!validDimLevels.containsAll(levels)) {
            isValid = false;
            if (!suppressException)
                throw new DataException(ResourceConstants.INVALID_BINDING_REFER_TO_INEXIST_DIMENSION, binding.getBindingName());
        }
        if ((binding.getAggregatOns().size() > 0 && binding.getAggrFunction() == null)) {
            isValid = false;
            if (!suppressException)
                throw new DataException(ResourceConstants.INVALID_BINDING_MISSING_AGGR_FUNC, binding.getBindingName());
        }
        if (!isValid)
            result.add(binding);
    }
    return result;
}

Output:
         }
-        if ((binding.getAggregatOns().size() > 0 && binding.getAggrFunction() == null)) {
-            isValid = false;
-            if (!suppressException)
-                throw new DataException(ResourceConstants.INVALID_BINDING_MISSING_AGGR_FUNC, binding.getBindingName());
+        if (binding.getAggregatOns().size() > 0) {
+            if (binding.getAggrFunction() == null) {
+                isValid = false;
+                if (!suppressException)
+                    throw new DataException(ResourceConstants.INVALID_BINDING_MISSING_AGGR_FUNC, binding.getBindingName());
+            }
+            Set lvls = new HashSet();
+            for (int j = 0; j < binding.getAggregatOns().size(); j++) {
+                lvls.add(OlapExpressionUtil.getTargetDimLevel(binding.getAggregatOns().get(j).toString()));
+            }
+            if (!validDimLevels.containsAll(lvls)) {
+                isValid = false;
+                if (!suppressException)
+                    throw new DataException(ResourceConstants.INVALID_BINDING_REFER_TO_INEXIST_DIMENSION, binding.getBindingName());
+            }
         }


Input:
public boolean kill() {
    int seq = lock.writeLock();
    try {
        while (true) {
            int seqRead = transformLive.readLock();
            AtomicPoint p = transformLive.getPosition();
            boolean alive = p.getWorld() != null;
            if (transformLive.readUnlock(seqRead)) {
                p.set(null, 0F, 0F, 0F);
                entityManagerLive = null;
                return alive;
            }
        }
    } finally {
        lock.writeUnlock(seq);
    }
}

Output:
     try {
-        while (true) {
-            int seqRead = transformLive.readLock();
-            AtomicPoint p = transformLive.getPosition();
-            boolean alive = p.getWorld() != null;
-            if (transformLive.readUnlock(seqRead)) {
-                p.set(null, 0F, 0F, 0F);
-                entityManagerLive = null;
-                return alive;
-            }
-        }
+        AtomicPoint p = transformLive.getPosition();
+        alive = p.getWorld() != null;
+        transformLive.set(DEAD);
     } finally {


Input:
public static synchronized String toPlainText(Context context) {
    StringBuilder sb = new StringBuilder();
    sb.append(getAppInfoHeaderText(context)).append("String_Node_Str").append(getDeviceInfoHeaderText(context)).append("String_Node_Str");
    Iterator<LogEntry> it = mLogEntries.iterator();
    int lineNum = 1;
    while (it.hasNext()) {
        LogEntry entry = it.next();
        sb.append(format(Locale.US, "String_Node_Str", lineNum)).append("String_Node_Str").append(entry.formatLogDate()).append("String_Node_Str").append(entry.mLogTag.name()).append("String_Node_Str").append(entry.mLogText).append("String_Node_Str");
        lineNum++;
    }
    return sb.toString();
}

Output:
     sb.append(getAppInfoHeaderText(context)).append("String_Node_Str").append(getDeviceInfoHeaderText(context)).append("String_Node_Str");
-    Iterator<LogEntry> it = mLogEntries.iterator();
+    Iterator<LogEntry> it = new ArrayList<>(mLogEntries).iterator();
     int lineNum = 1;


Input:
public void onValueChange(ValueChangeEvent<Date> event) {
    panel.hide();
    Date date = event.getValue();
    setViewData(lastKey, date);
    setValue(lastParent, lastValue, lastKey);
    if (valueUpdater != null) {
        valueUpdater.update(date);
    }
}

Output:
     Date date = event.getValue();
-    setViewData(lastKey, date);
-    setValue(lastParent, lastValue, lastKey);
+    setViewData(key, date);
+    setValue(cellParent, oldValue, key);
     if (valueUpdater != null) {


Input:
public void onEventMainThread(MessageEvent event) {
    getViewModel().updateOfficeData();
}

Output:
 public void onEventMainThread(MessageEvent event) {
-    getViewModel().updateOfficeData();
+    getViewModel().updateOfficeData(((TextContent) event.getMessage().getContent()).getText());
 }


Input:
protected void render() {
    clearDynamicList();
    allExpandableCompositeList.clear();
    columnCompositeMap.clear();
    for (final ModelElementIndicator modelElementIndicator : modelElementIndicators) {
        ExpandableComposite exComp = uiPagination.getToolkit().createExpandableComposite(uiPagination.getChartComposite(), ExpandableComposite.TWISTIE | ExpandableComposite.CLIENT_INDENT | ExpandableComposite.EXPANDED | ExpandableComposite.LEFT_TEXT_CLIENT_ALIGNMENT);
        needDispostWidgets.add(exComp);
        allExpandableCompositeList.add(exComp);
        IRepositoryNode modelElementRepositoryNode = modelElementIndicator.getModelElementRepositoryNode();
        IRepositoryNode parentNodeForColumnNode = RepositoryNodeHelper.getParentNodeForColumnNode(modelElementRepositoryNode);
        String label = parentNodeForColumnNode.getObject().getLabel();
        if (label != null && !label.equals("String_Node_Str")) {
            label = label.concat("String_Node_Str").concat(modelElementIndicator.getElementName());
        } else {
            label = modelElementIndicator.getElementName();
        }
        exComp.setText(DefaultMessagesImpl.getString("String_Node_Str", label));
        exComp.setLayout(new GridLayout());
        exComp.setLayoutData(new GridData(GridData.FILL_BOTH));
        exComp.setExpanded(EditorPreferencePage.isUnfoldingAnalyzedEelementsResultPage());
        Composite collapseExpandComposite = uiPagination.getToolkit().createComposite(exComp);
        GridLayout gdLayout = new GridLayout();
        gdLayout.numColumns = 2;
        collapseExpandComposite.setLayout(gdLayout);
        createCollapseAllLink(collapseExpandComposite, label);
        createExpandAllLink(collapseExpandComposite, label);
        exComp.setTextClient(collapseExpandComposite);
        final Composite comp = uiPagination.getToolkit().createComposite(exComp);
        comp.setLayout(new GridLayout());
        comp.setLayoutData(new GridData(GridData.FILL_BOTH));
        exComp.setClient(comp);
        createResultDataComposite(comp, modelElementIndicator);
        columnCompositeMap.put(label, comp);
        exComp.addExpansionListener(new ExpansionAdapter() {
            public void expansionStateChanged(ExpansionEvent e) {
                uiPagination.getChartComposite().layout();
                form.reflow(true);
            }
        });
        uiPagination.getChartComposite().layout();
        masterPage.registerSection(exComp);
    }
}

Output:
     columnCompositeMap.clear();
-    for (final ModelElementIndicator modelElementIndicator : modelElementIndicators) {
+    for (ModelElementIndicator modelElementIndicator : modelElementIndicators) {
         ExpandableComposite exComp = uiPagination.getToolkit().createExpandableComposite(uiPagination.getChartComposite(), ExpandableComposite.TWISTIE | ExpandableComposite.CLIENT_INDENT | ExpandableComposite.EXPANDED | ExpandableComposite.LEFT_TEXT_CLIENT_ALIGNMENT);


Input:
public Word guessByEnding(String word) {
    Word rezultāts = new Word(word);
    for (int i = word.length() - 3; i >= 0; i--) {
        for (Ending ending : getAllEndings().matchedEndings(word)) if (ending.getEnding().length() == i) {
            if (ending.getParadigm().getName().equals("String_Node_Str"))
                continue;
            ArrayList<Variants> celmi = Mijas.mijuVarianti(ending.stem(word), ending.getMija());
            if (celmi.size() == 0)
                continue;
            String celms = celmi.get(0).celms;
            Wordform variants = new Wordform(word, null, ending);
            variants.addAttribute(AttributeNames.i_Source, "String_Node_Str");
            variants.addAttribute(AttributeNames.i_Guess, AttributeNames.v_Ending);
            Ending pamatforma = ending.getLemmaEnding();
            if (ending.getParadigm().getID() == 4 && !(celms.endsWith("String_Node_Str") || celms.endsWith("String_Node_Str")))
                continue;
            if (pamatforma != null)
                variants.addAttribute(AttributeNames.i_Lemma, celms + pamatforma.getEnding());
            if ((this.guessNouns && ending.getParadigm().isMatchingStrong(AttributeNames.i_PartOfSpeech, AttributeNames.v_Noun) && (enableVocative || !variants.isMatchingStrong(AttributeNames.i_Case, AttributeNames.v_Vocative)) && (guessInflexibeNouns || !variants.isMatchingStrong(AttributeNames.i_Declension, AttributeNames.v_NA))) || (this.guessVerbs && ending.getParadigm().isMatchingWeak(AttributeNames.i_PartOfSpeech, AttributeNames.v_Verb)) || (this.guessAdjectives && ending.getParadigm().isMatchingStrong(AttributeNames.i_PartOfSpeech, AttributeNames.v_Adjective)) || (this.guessParticibles && variants.isMatchingStrong(AttributeNames.i_Izteiksme, AttributeNames.v_Participle)))
                rezultāts.wordforms.add(variants);
        }
        if (rezultāts.isRecognized() && !enableAllGuesses)
            break;
    }
    return rezultāts;
}

Output:
                 variants.addAttribute(AttributeNames.i_Lemma, celms + pamatforma.getEnding());
-            if ((this.guessNouns && ending.getParadigm().isMatchingStrong(AttributeNames.i_PartOfSpeech, AttributeNames.v_Noun) && (enableVocative || !variants.isMatchingStrong(AttributeNames.i_Case, AttributeNames.v_Vocative)) && (guessInflexibeNouns || !variants.isMatchingStrong(AttributeNames.i_Declension, AttributeNames.v_NA))) || (this.guessVerbs && ending.getParadigm().isMatchingWeak(AttributeNames.i_PartOfSpeech, AttributeNames.v_Verb)) || (this.guessAdjectives && ending.getParadigm().isMatchingStrong(AttributeNames.i_PartOfSpeech, AttributeNames.v_Adjective)) || (this.guessParticibles && variants.isMatchingStrong(AttributeNames.i_Izteiksme, AttributeNames.v_Participle)))
+            if ((this.guessNouns && ending.getParadigm().isMatchingStrong(AttributeNames.i_PartOfSpeech, AttributeNames.v_Noun) && (enableVocative || !variants.isMatchingStrong(AttributeNames.i_Case, AttributeNames.v_Vocative)) && (guessInflexibleNouns || !variants.isMatchingStrong(AttributeNames.i_Declension, AttributeNames.v_NA))) || (this.guessVerbs && ending.getParadigm().isMatchingWeak(AttributeNames.i_PartOfSpeech, AttributeNames.v_Verb)) || (this.guessAdjectives && ending.getParadigm().isMatchingStrong(AttributeNames.i_PartOfSpeech, AttributeNames.v_Adjective)) || (this.guessParticibles && variants.isMatchingStrong(AttributeNames.i_Izteiksme, AttributeNames.v_Participle)))
                 rezultāts.wordforms.add(variants);


Input:
protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
    String[] correctionModeValues = new String[] { translate("String_Node_Str"), translate("String_Node_Str") };
    correctionModeEl = uifactory.addRadiosVertical("String_Node_Str", "String_Node_Str", formLayout, correctionModeKeys, correctionModeValues);
    String mode = modConfig.getStringValue(IQEditController.CONFIG_CORRECTION_MODE);
    boolean selected = false;
    for (String correctionModeKey : correctionModeKeys) {
        if (correctionModeKey.equals(mode)) {
            correctionModeEl.select(correctionModeKey, true);
            selected = true;
        }
    }
    if (!selected) {
        if (needManulCorrection) {
            correctionModeEl.select(correctionModeKeys[1], true);
        } else {
            correctionModeEl.select(correctionModeKeys[0], true);
        }
    }
    boolean fullWindow = modConfig.getBooleanSafe(IQEditController.CONFIG_FULLWINDOW);
    fullWindowEl = uifactory.addCheckboxesHorizontal("String_Node_Str", "String_Node_Str", formLayout, new String[] { "String_Node_Str" }, new String[] { "String_Node_Str" });
    fullWindowEl.select("String_Node_Str", fullWindow);
    boolean showTitles = mergeBoolean(modConfig.getBooleanEntry(IQEditController.CONFIG_KEY_QUESTIONTITLE), deliveryOptions.isDisplayQuestionProgress());
    showTitlesEl = uifactory.addCheckboxesHorizontal("String_Node_Str", "String_Node_Str", formLayout, onKeys, onValues);
    if (showTitles) {
        showTitlesEl.select(onKeys[0], true);
    }
    boolean personalNotes = mergeBoolean(modConfig.getBooleanEntry(IQEditController.CONFIG_KEY_MEMO), deliveryOptions.isDisplayQuestionProgress());
    personalNotesEl = uifactory.addCheckboxesHorizontal("String_Node_Str", "String_Node_Str", formLayout, onKeys, onValues);
    if (personalNotes) {
        personalNotesEl.select(onKeys[0], true);
    }
    boolean questionProgress = mergeBoolean(modConfig.getBooleanEntry(IQEditController.CONFIG_KEY_QUESTIONPROGRESS), deliveryOptions.isDisplayQuestionProgress());
    displayQuestionProgressEl = uifactory.addCheckboxesHorizontal("String_Node_Str", "String_Node_Str", formLayout, onKeys, onValues);
    if (questionProgress) {
        displayQuestionProgressEl.select(onKeys[0], true);
    }
    boolean questionScore = mergeBoolean(modConfig.getBooleanEntry(IQEditController.CONFIG_KEY_SCOREPROGRESS), deliveryOptions.isDisplayScoreProgress());
    displayScoreProgressEl = uifactory.addCheckboxesHorizontal("String_Node_Str", "String_Node_Str", formLayout, onKeys, onValues);
    if (questionScore) {
        displayScoreProgressEl.select(onKeys[0], true);
    }
    boolean enableSuspend = mergeBoolean(modConfig.getBooleanEntry(IQEditController.CONFIG_KEY_ENABLESUSPEND), deliveryOptions.isEnableSuspend());
    enableSuspendEl = uifactory.addCheckboxesHorizontal("String_Node_Str", "String_Node_Str", formLayout, onKeys, onValues);
    if (enableSuspend) {
        enableSuspendEl.select(onKeys[0], true);
    }
    boolean enableCancel = mergeBoolean(modConfig.getBooleanEntry(IQEditController.CONFIG_KEY_ENABLECANCEL), deliveryOptions.isEnableCancel());
    enableCancelEl = uifactory.addCheckboxesHorizontal("String_Node_Str", "String_Node_Str", formLayout, onKeys, onValues);
    if (enableCancel) {
        enableCancelEl.select(onKeys[0], true);
    }
    uifactory.addFormSubmitButton("String_Node_Str", formLayout);
}

Output:
     fullWindowEl.select("String_Node_Str", fullWindow);
-    boolean showTitles = mergeBoolean(modConfig.getBooleanEntry(IQEditController.CONFIG_KEY_QUESTIONTITLE), deliveryOptions.isDisplayQuestionProgress());
+    boolean showTitles = modConfig.getBooleanSafe(IQEditController.CONFIG_KEY_QUESTIONTITLE, deliveryOptions.isDisplayQuestionProgress());
     showTitlesEl = uifactory.addCheckboxesHorizontal("String_Node_Str", "String_Node_Str", formLayout, onKeys, onValues);


Input:
private synchronized void sendMessage(String msgName, GeneratedMessage msg, boolean checkReady) throws Exception {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    baos.write(msgName.getBytes());
    baos.write(0);
    baos.write(Dlugosz.encode(msg.getSerializedSize()).array());
    msg.writeTo(baos);
    if (checkReady) {
        while (!handshakeComplete) wait();
    }
    byte[] sendData = baos.toByteArray();
    log.debug("String_Node_Str" + msgName + "String_Node_Str" + msg + "String_Node_Str" + nodeId.toString() + "String_Node_Str" + sendData.length + "String_Node_Str");
    try {
        dataChan.receiveData(ByteBuffer.wrap(sendData), null);
    } catch (IOException e) {
        if (!closing) {
            if (CodeUtil.javaMajorVersion() >= 6)
                throw new IOException(e);
            throw new IOException("String_Node_Str" + e.getClass().getSimpleName() + "String_Node_Str" + e.getMessage());
        }
    }
}

Output:
     if (checkReady) {
-        while (!handshakeComplete) wait();
+        while (!handshakeComplete) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                if (CodeUtil.javaMajorVersion() >= 6)
+                    throw new IOException(e);
+                else
+                    throw new IOException("String_Node_Str");
+            }
+        }
     }


Input:
public boolean doInteraction(Object arg) {
    Configuration configuration = JDUtilities.getConfiguration();
    String script = configuration.getStringProperty(Configuration.PARAM_HTTPSEND_REQUESTS);
    String user = configuration.getStringProperty(Configuration.PARAM_HTTPSEND_USER);
    String pass = configuration.getStringProperty(Configuration.PARAM_HTTPSEND_PASS);
    String ip = configuration.getStringProperty(Configuration.PARAM_HTTPSEND_IP);
    retries++;
    logger.info("String_Node_Str" + retries);
    ProgressController progress = new ProgressController(JDLocale.L("String_Node_Str", "String_Node_Str"), 10);
    progress.setStatusText(JDLocale.L("String_Node_Str", "String_Node_Str" + retries));
    if (user != null || pass != null)
        Authenticator.setDefault(new InternalAuthenticator(user, pass));
    if (script == null) {
        progress.finalize();
        return parseError("String_Node_Str");
    }
    String preIp = JDUtilities.getIPAddress();
    logger.finer("String_Node_Str" + preIp);
    progress.setStatusText(JDLocale.L("String_Node_Str", "String_Node_Str") + preIp);
    script = script.replaceAll("String_Node_Str", "String_Node_Str");
    script = script.replaceAll("String_Node_Str", "String_Node_Str");
    script = script.replaceAll("String_Node_Str", "String_Node_Str");
    script = script.replaceAll("String_Node_Str", "String_Node_Str");
    script = script.replaceAll("String_Node_Str", "String_Node_Str");
    script = script.replaceAll("String_Node_Str", "String_Node_Str");
    Document xmlScript;
    variables = new HashMap<String, String>();
    variables.put("String_Node_Str", user);
    variables.put("String_Node_Str", pass);
    variables.put("String_Node_Str", new BASE64Encoder().encode((user + "String_Node_Str" + pass).getBytes()));
    variables.put("String_Node_Str", ip);
    headerProperties = new HashMap<String, String>();
    progress.increase(1);
    try {
        xmlScript = parseXmlString(script, false);
        Node root = xmlScript.getChildNodes().item(0);
        if (root == null || !root.getNodeName().equalsIgnoreCase("String_Node_Str")) {
            progress.finalize();
            return parseError("String_Node_Str");
        }
        RequestInfo requestInfo = null;
        NodeList steps = root.getChildNodes();
        progress.addToMax(steps.getLength());
        for (int step = 0; step < steps.getLength(); step++) {
            progress.setStatusText(JDLocale.L("String_Node_Str", "String_Node_Str") + step);
            progress.increase(1);
            Node current = steps.item(step);
            if (current.getNodeType() == 3) {
                continue;
            }
            if (!current.getNodeName().equalsIgnoreCase("String_Node_Str")) {
                progress.finalize();
                return parseError("String_Node_Str" + current.getNodeName());
            }
            NodeList toDos = current.getChildNodes();
            for (int toDoStep = 0; toDoStep < toDos.getLength(); toDoStep++) {
                Node toDo = toDos.item(toDoStep);
                progress.setStatusText(JDUtilities.sprintf(JDLocale.L("String_Node_Str", "String_Node_Str"), new String[] { toDo.getNodeName() }));
                if (toDo.getNodeName().equalsIgnoreCase("String_Node_Str")) {
                    NamedNodeMap attributes = toDo.getAttributes();
                    for (int attribute = 0; attribute < attributes.getLength(); attribute++) {
                        String key = attributes.item(attribute).getNodeName();
                        String value = attributes.item(attribute).getNodeValue();
                        String[] tmp = value.split("String_Node_Str");
                        ArrayList<String> params = Plugin.getAllSimpleMatches(value, "String_Node_Str", 1);
                        if (params.size() > 0) {
                            String req;
                            if (value.startsWith(params.get(0))) {
                                req = "String_Node_Str";
                                logger.finer("String_Node_Str" + this.variables);
                                logger.finer("String_Node_Str" + this.headerProperties);
                                for (int i = 0; i <= tmp.length; i++) {
                                    logger.finer("String_Node_Str" + params.get(i - 1) + "String_Node_Str");
                                    req += getModifiedVariable(params.get(i - 1));
                                    if (i < tmp.length) {
                                        req += tmp[i];
                                    }
                                }
                            } else {
                                req = tmp[0];
                                logger.finer("String_Node_Str" + this.variables);
                                logger.finer("String_Node_Str" + this.headerProperties);
                                for (int i = 1; i <= tmp.length; i++) {
                                    if (i > params.size())
                                        continue;
                                    logger.finer("String_Node_Str" + params.get(i - 1) + "String_Node_Str");
                                    req += getModifiedVariable(params.get(i - 1));
                                    if (i < tmp.length) {
                                        req += tmp[i];
                                    }
                                }
                            }
                            value = req;
                        }
                        variables.put(key, value);
                    }
                    logger.finer("String_Node_Str" + variables);
                }
                if (toDo.getNodeName().equalsIgnoreCase("String_Node_Str")) {
                    if (toDo.getChildNodes().getLength() != 1) {
                        progress.finalize();
                        return parseError("String_Node_Str");
                    }
                    requestInfo = doRequest(toDo.getChildNodes().item(0).getNodeValue().trim());
                    if (requestInfo == null) {
                        logger.severe("String_Node_Str" + toDo.getChildNodes().item(0).getNodeValue().trim());
                    }
                }
                if (toDo.getNodeName().equalsIgnoreCase("String_Node_Str")) {
                    logger.finer("String_Node_Str");
                    if (toDo.getChildNodes().getLength() != 1) {
                        progress.finalize();
                        return parseError("String_Node_Str");
                    }
                    NamedNodeMap attributes = toDo.getAttributes();
                    if (attributes.getNamedItem("String_Node_Str") == null) {
                        progress.finalize();
                        return parseError("String_Node_Str" + toDo);
                    }
                    String[] keys = attributes.getNamedItem("String_Node_Str").getNodeValue().split("String_Node_Str");
                    getVariables(toDo.getChildNodes().item(0).getNodeValue().trim(), keys, requestInfo);
                }
                if (toDo.getNodeName().equalsIgnoreCase("String_Node_Str")) {
                    NamedNodeMap attributes = toDo.getAttributes();
                    Node item = attributes.getNamedItem("String_Node_Str");
                    logger.finer("String_Node_Str" + item.getNodeValue() + "String_Node_Str");
                    if (item == null) {
                        return parseError("String_Node_Str");
                    }
                    int seconds = JDUtilities.filterInt(item.getNodeValue());
                    Thread.sleep(seconds * 1000);
                }
            }
        }
    } catch (SAXException e) {
        progress.finalize();
        return this.parseError(e.getMessage());
    } catch (ParserConfigurationException e) {
        e.printStackTrace();
        progress.finalize();
        return this.parseError(e.getMessage());
    } catch (Exception e) {
        e.printStackTrace();
        progress.finalize();
        return this.parseError(e.getCause() + "String_Node_Str" + e.getMessage());
    }
    int waittime = configuration.getIntegerProperty(Configuration.PARAM_HTTPSEND_IPCHECKWAITTIME, 0);
    int maxretries = configuration.getIntegerProperty(Configuration.PARAM_HTTPSEND_RETRIES, 0);
    int waitForIp = configuration.getIntegerProperty(Configuration.PARAM_HTTPSEND_WAITFORIPCHANGE, 10);
    logger.finer("String_Node_Str" + waittime + "String_Node_Str");
    progress.increase(1);
    progress.setStatusText(JDLocale.L("String_Node_Str", "String_Node_Str"));
    try {
        Thread.sleep(waittime * 1000);
    } catch (InterruptedException e) {
    }
    String afterIP = JDUtilities.getIPAddress();
    logger.finer("String_Node_Str" + afterIP);
    progress.increase(1);
    String pattern = JDLocale.L("String_Node_Str", "String_Node_Str");
    progress.setStatusText(JDUtilities.sprintf(pattern, new String[] { preIp, afterIP }));
    long endTime = System.currentTimeMillis() + waitForIp * 1000;
    while (System.currentTimeMillis() <= endTime && (afterIP.equalsIgnoreCase("String_Node_Str") || afterIP == null || afterIP.equals(preIp))) {
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
        }
        afterIP = JDUtilities.getIPAddress();
        pattern = JDLocale.L("String_Node_Str", "String_Node_Str");
        progress.setStatusText(JDUtilities.sprintf(pattern, new String[] { preIp, afterIP }));
        logger.finer("String_Node_Str" + afterIP);
    }
    if (!afterIP.equals(preIp) && !afterIP.equalsIgnoreCase("String_Node_Str")) {
        progress.finalize();
        logger.info("String_Node_Str" + afterIP);
        return true;
    }
    if (retries <= maxretries) {
        progress.finalize();
        return doInteraction(arg);
    }
    progress.finalize();
    logger.info("String_Node_Str" + afterIP);
    return false;
}

Output:
                 Node toDo = toDos.item(toDoStep);
-                progress.setStatusText(JDUtilities.sprintf(JDLocale.L("String_Node_Str", "String_Node_Str"), new String[] { toDo.getNodeName() }));
+                try {
+                    progress.setStatusText(JDUtilities.sprintf(JDLocale.L("String_Node_Str", "String_Node_Str"), new String[] { toDo.getNodeName() }));
+                } catch (Exception e) {
+                }
                 if (toDo.getNodeName().equalsIgnoreCase("String_Node_Str")) {


Input:
private boolean overlapsWith(Relationship r, Relationship s) {
    return mrcaTipsAndInternal(s.getId()).containsAny(mrcaTipsAndInternal(r.getId()));
}

Output:
 private boolean overlapsWith(Relationship r, Relationship s) {
-    return mrcaTipsAndInternal(s.getId()).containsAny(mrcaTipsAndInternal(r.getId()));
+    return mrcaTipsAndInternal(s.getStartNode()).containsAny(mrcaTipsAndInternal(r.getStartNode()));
 }


Input:
private void initialize() {
    IResource resource = (project == null) ? this.model : this.project;
    int size = (project == null) ? 3 : 2;
    this.pvdbFile = getContext().getPreviewVdb(resource);
    ISchedulingRule[] rules = new ISchedulingRule[size];
    rules[0] = getSchedulingRuleFactory().createRule(this.pvdbFile);
    rules[1] = getSchedulingRuleFactory().modifyRule(this.pvdbFile);
    if (size == 3) {
        rules[2] = getSchedulingRuleFactory().modifyRule(this.model);
    }
    setRule(MultiRule.combine(rules));
}

Output:
     IResource resource = (project == null) ? this.model : this.project;
-    int size = (project == null) ? 3 : 2;
+    int size = (project == null) ? 4 : 3;
     this.pvdbFile = getContext().getPreviewVdb(resource);


Input:
public static Chain getMatchingAtomRes(Chain seqRes, List<Chain> atomList) {
    Iterator<Chain> iter = atomList.iterator();
    while (iter.hasNext()) {
        Chain atomChain = iter.next();
        if (atomChain.getName().equals(seqRes.getName())) {
            return atomChain;
        }
    }
    logger.info("String_Node_Str" + seqRes.getId() + "String_Node_Str" + seqRes.getName() + "String_Node_Str" + atomList.size());
    return null;
}

Output:
         Chain atomChain = iter.next();
-        if (atomChain.getName().equals(seqRes.getName())) {
+        String atomChainId = null;
+        String seqResChainId = null;
+        if (useChainId) {
+            atomChainId = atomChain.getId();
+            seqResChainId = seqRes.getId();
+        } else {
+            atomChainId = atomChain.getName();
+            seqResChainId = seqRes.getName();
+        }
+        if (atomChainId.equals(seqResChainId)) {
             return atomChain;


Input:
public XMLDBModel populateChildModelsList(XMLDBModel model) throws XMLDBModelParsingException {
    if (model.getModel() == null) {
        return model;
    }
    model.setReferencedChildren(new ArrayList<String>());
    Document modelDocument = (Document) Utilities.parseXML(model.getModel());
    Node topEntityNode = modelDocument.getElementsByTagName("String_Node_Str").item(0);
    NodeList entityList = topEntityNode.getChildNodes();
    boolean isChanged = false;
    if (entityList != null) {
        for (int i = 0; i < entityList.getLength(); i++) {
            Node entity = entityList.item(i);
            if (!"String_Node_Str".equals(entity.getNodeName())) {
                continue;
            }
            NodeList parameterList = entity.getChildNodes();
            String referencedModelId = null;
            boolean isReferenced = false;
            int noOfParametersFound = 0;
            for (int j = 0; j < parameterList.getLength(); j++) {
                Node parameter = parameterList.item(j);
                if ("String_Node_Str".equals(parameter.getNodeName())) {
                    String name = Utilities.getValueForAttribute(parameter, "String_Node_Str");
                    if (XMLDBModel.DB_MODEL_ID_ATTR.equals(name)) {
                        referencedModelId = Utilities.getValueForAttribute(parameter, "String_Node_Str");
                        noOfParametersFound++;
                    } else if (XMLDBModel.DB_REFERENCE_ATTR.equals(name)) {
                        String value = Utilities.getValueForAttribute(parameter, "String_Node_Str");
                        isReferenced = "String_Node_Str".equals(value);
                        noOfParametersFound++;
                    }
                    if (noOfParametersFound == 2) {
                        break;
                    }
                }
            }
            if (isReferenced && referencedModelId != null) {
                Element entityElement = (Element) entity.cloneNode(false);
                NodeList childNodesList = entity.getChildNodes();
                for (int k = 0; k < childNodesList.getLength(); k++) {
                    Node childNode = childNodesList.item(k);
                    if ("String_Node_Str".equals(childNode.getNodeName())) {
                        String name = Utilities.getValueForAttribute(childNode, "String_Node_Str");
                        if (name != null && (name.startsWith("String_Node_Str") || XMLDBModel.DB_REFERENCE_ATTR.equals(name) || XMLDBModel.DB_MODEL_ID_ATTR.equals(name))) {
                            entityElement.appendChild(childNode);
                        }
                    }
                }
                entityElement.setAttribute(XMLDBModel.DB_MODEL_ID_ATTR, referencedModelId);
                topEntityNode.replaceChild(entityElement, entity);
                model.addReferencedChild(referencedModelId);
                isChanged = true;
            }
        }
    }
    if (isChanged) {
        String newModelContent = Utilities.getDocumentXMLString(modelDocument);
        model.setModel(newModelContent);
    }
    return model;
}

Output:
             boolean isReferenced = false;
-            int noOfParametersFound = 0;
+            boolean isReferencedFound = false;
+            boolean dbModelIdFound = false;
             for (int j = 0; j < parameterList.getLength(); j++) {


Input:
protected void onClick() {
    if (enabled) {
        Dungeon.hero.handle(lastTarget.pos);
    }
}

Output:
 protected void onClick() {
-    if (enabled) {
+    if (Dungeon.hero.curAction != null)
+        Dungeon.hero.interrupt();
+    else
         Dungeon.hero.handle(lastTarget.pos);


Input:
private boolean setTargetPlayer(Outcome outcome, Target target, Ability source, UUID sourceId, UUID abilityControllerId, UUID randomOpponentId, Game game) {
    if (target instanceof TargetOpponent) {
        if (source == null) {
            if (((TargetOpponent) target).canTarget(randomOpponentId, game)) {
                target.add(randomOpponentId, game);
                return true;
            }
        } else if (((TargetOpponent) target).canTarget(randomOpponentId, source, game)) {
            target.add(randomOpponentId, game);
            return true;
        }
        for (UUID currentId : game.getOpponents(abilityControllerId)) {
            if (source == null) {
                if (((TargetOpponent) target).canTarget(currentId, game)) {
                    target.add(currentId, game);
                    return true;
                }
            } else if (((TargetOpponent) target).canTarget(currentId, source, game)) {
                target.add(currentId, game);
                return true;
            }
        }
        return false;
    }
    if (target instanceof TargetPlayer) {
        if (outcome.isGood()) {
            if (source == null) {
                if (target.canTarget(abilityControllerId, game)) {
                    target.add(abilityControllerId, game);
                    return true;
                }
                if (target.isRequired(sourceId, game)) {
                    if (target.canTarget(randomOpponentId, game)) {
                        target.add(randomOpponentId, game);
                        return true;
                    }
                }
            } else {
                if (target.canTarget(abilityControllerId, abilityControllerId, source, game)) {
                    target.addTarget(playerId, source, game);
                    return true;
                }
                if (target.isRequired(sourceId, game)) {
                    if (target.canTarget(randomOpponentId, game)) {
                        target.add(randomOpponentId, game);
                        return true;
                    }
                }
            }
        } else if (source == null) {
            if (target.canTarget(randomOpponentId, game)) {
                target.add(randomOpponentId, game);
                return true;
            }
            if (target.isRequired(sourceId, game)) {
                if (target.canTarget(abilityControllerId, game)) {
                    target.add(abilityControllerId, game);
                    return true;
                }
            }
        } else {
            if (target.canTarget(randomOpponentId, game)) {
                target.add(randomOpponentId, game);
                return true;
            }
            if (target.isRequired(sourceId, game)) {
                if (target.canTarget(abilityControllerId, game)) {
                    target.add(abilityControllerId, game);
                    return true;
                }
            }
        }
        return false;
    }
    return false;
}

Output:
 private boolean setTargetPlayer(Outcome outcome, Target target, Ability source, UUID sourceId, UUID abilityControllerId, UUID randomOpponentId, Game game) {
-    if (target instanceof TargetOpponent) {
+    if (target.getOriginalTarget() instanceof TargetOpponent) {
         if (source == null) {


Input:
private void generateAny(ElementDefn root, ElementDefn e, String prefix, JsonObject props, boolean relative) throws Exception {
    for (TypeRef t : datatypes) {
        JsonObject property = new JsonObject();
        JsonObject property_ = null;
        String en = e.getName().replace("String_Node_Str", "String_Node_Str");
        props.add(en + upFirst(t.getName()), property);
        property.addProperty("String_Node_Str", e.getDefinition());
        String tref = null;
        String type = null;
        String pattern = null;
        if (definitions.getPrimitives().containsKey(t.getName())) {
            DefinedCode def = definitions.getPrimitives().get(t.getName());
            type = def.getJsonType();
            pattern = def.getRegex();
            if (!Utilities.noString(pattern))
                property.addProperty("String_Node_Str", pattern);
            property.addProperty("String_Node_Str", type);
            property_ = new JsonObject();
            props.add(en + upFirst(t.getName()) + "String_Node_Str", property_);
            property_.addProperty("String_Node_Str", "String_Node_Str" + en + upFirst(t.getName()));
            tref = (relative ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str";
            property_.addProperty("String_Node_Str", tref);
        } else {
            String tn = encodeType(e, t, true);
            tref = (relative ? "String_Node_Str" : tn + "String_Node_Str") + "String_Node_Str" + tn;
            property.addProperty("String_Node_Str", tref);
        }
    }
}

Output:
             property_ = new JsonObject();
-            props.add(en + upFirst(t.getName()) + "String_Node_Str", property_);
+            props.add("String_Node_Str" + en + upFirst(t.getName()), property_);
             property_.addProperty("String_Node_Str", "String_Node_Str" + en + upFirst(t.getName()));


Input:
private String tab() {
    if (tab == null) {
        tab = getMarshaller().getIndentString();
    }
    return tab;
}

Output:
     if (tab == null) {
-        tab = getMarshaller().getIndentString();
+        String sTab = getMarshaller().getIndentString();
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        writeValue(sTab, true, false, baos);
+        tab = baos.toByteArray();
     }


Input:
public void fireEvent(Hertz event) {
    COLLECTION_INTERVAL_TIME_MS = (((int) TimeUnit.MINUTES.toMillis(DEFAULT_POLL_INTERVAL_MINS)) / HISTORY_SIZE) * 2;
    if (COLLECTION_INTERVAL_TIME_MS <= MAX_WRITE_INTERVAL_MS) {
        try {
            if (event.isAsserted(DEFAULT_POLL_INTERVAL_MINS)) {
                if (Bootstrap.isFinished() && Hosts.isCoordinator()) {
                    for (final ServiceConfiguration ccConfig : Topology.enabledServices(ClusterController.class)) {
                        AsyncRequests.newRequest(new DescribeSensorCallback(HISTORY_SIZE, COLLECTION_INTERVAL_TIME_MS)).dispatch(ccConfig);
                        LOG.debug("String_Node_Str");
                    }
                }
            }
        } catch (Exception ex) {
            LOG.error("String_Node_Str", ex);
        }
    } else {
        LOG.error("String_Node_Str" + DEFAULT_POLL_INTERVAL_MINS + "String_Node_Str");
    }
}

Output:
 public void fireEvent(Hertz event) {
-    COLLECTION_INTERVAL_TIME_MS = (((int) TimeUnit.MINUTES.toMillis(DEFAULT_POLL_INTERVAL_MINS)) / HISTORY_SIZE) * 2;
+    COLLECTION_INTERVAL_TIME_MS = ((int) TimeUnit.MINUTES.toMillis(DEFAULT_POLL_INTERVAL_MINS) / 2);
     if (COLLECTION_INTERVAL_TIME_MS <= MAX_WRITE_INTERVAL_MS) {


Input:
public boolean onQueryTextChange(String newText) {
    constraint = newText;
    if (state == State.FRIENDS_LIST) {
        FriendsListCursorAdapter friendListCursorAdapter = (FriendsListCursorAdapter) friendsListAdapter;
        friendListCursorAdapter.setFilterQueryProvider(this);
        friendListCursorAdapter.getFilter().filter(newText);
        friendListCursorAdapter.setSearchCharacters(newText);
    } else {
        startUsersListLoader(newText);
    }
    return true;
}

Output:
     if (state == State.FRIENDS_LIST) {
-        FriendsListCursorAdapter friendListCursorAdapter = (FriendsListCursorAdapter) friendsListAdapter;
-        friendListCursorAdapter.setFilterQueryProvider(this);
-        friendListCursorAdapter.getFilter().filter(newText);
-        friendListCursorAdapter.setSearchCharacters(newText);
+        friendsListAdapter.setFilterQueryProvider(this);
+        friendsListAdapter.getFilter().filter(newText);
+        friendsListAdapter.setSearchCharacters(newText);
     } else {


Input:
int getMaxConcurrentVirtualSpouts() {
    return (int) getTopologyConfig().get(SidelineSpoutConfig.MAX_CONCURRENT_VIRTUAL_SPOUTS);
}

Output:
 int getMaxConcurrentVirtualSpouts() {
-    return (int) getTopologyConfig().get(SidelineSpoutConfig.MAX_CONCURRENT_VIRTUAL_SPOUTS);
+    return ((Number) getTopologyConfig().get(SidelineSpoutConfig.MAX_CONCURRENT_VIRTUAL_SPOUTS)).intValue();
 }


Input:
public static CtClass getCtClass(String className) throws BytecodeManipulationException {
    try {
        return classPool.get(className);
    } catch (Exception e) {
        throw new BytecodeManipulationException("String_Node_Str", e);
    }
}

Output:
     } catch (Exception e) {
-        throw new BytecodeManipulationException("String_Node_Str", e);
+        return null;
     }


Input:
public void run() {
    try {
        setContentView(R.layout.activity_rashr);
        mToolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(mToolbar);
        mNavigationDrawerFragment = (NavigationDrawerFragment) getSupportFragmentManager().findFragmentById(R.id.navigation_drawer);
        mNavigationDrawerFragment.setUp(R.id.navigation_drawer, (DrawerLayout) findViewById(R.id.RashrLayout));
        AdView ads = (AdView) findViewById(R.id.ads);
        if (ads != null) {
            if (Common.getBooleanPref(mContext, Const.PREF_NAME, Const.PREF_KEY_ADS)) {
                ads.loadAd(new AdRequest().addTestDevice("String_Node_Str"));
            }
        }
        if (getIntent().getAction().equals(Intent.ACTION_VIEW)) {
            if (getIntent().getData().toString().endsWith("String_Node_Str")) {
                File zip = new File(getIntent().getData().getPath());
                if (zip.exists())
                    switchTo(ScriptManagerFragment.newInstance(mActivity, zip));
            } else {
                File img = new File(getIntent().getData().getPath());
                if (img.exists())
                    switchTo(FlashAsFragment.newInstance(mActivity, img, true));
            }
        } else {
            onNavigationDrawerItemSelected(0);
        }
    } catch (NullPointerException e) {
        setContentView(R.layout.err_layout);
        mActivity.addError(Const.RASHR_TAG, e, false);
        AppCompatTextView tv = (AppCompatTextView) findViewById(R.id.tvErr);
        try {
            tv.setText(R.string.failed_setup_layout);
        } catch (RuntimeException ex) {
            mActivity.addError(Const.RASHR_TAG, e, true);
            ex.printStackTrace();
        }
    }
}

Output:
     try {
-        setContentView(R.layout.activity_rashr);
+        View root = View.inflate(mContext, R.layout.activity_rashr, null);
+        root.startAnimation(AnimationUtils.loadAnimation(mContext, R.anim.abc_grow_fade_in_from_bottom));
+        setContentView(root);
         mToolbar = (Toolbar) findViewById(R.id.toolbar);


Input:
public void testProjectsLoadAfterProjectChange() throws IOException {
    CubeInstance cube = CubeManager.getInstance(getTestConfig()).getCube("String_Node_Str");
    assertTrue(ProjectManager.getInstance(this.getTestConfig()).getRealizationsByTable("String_Node_Str", "String_Node_Str").contains(cube));
    ProjectManager.getInstance(getTestConfig()).removeRealizationsFromProjects(RealizationType.CUBE, cube.getName());
    assertTrue(!ProjectManager.getInstance(this.getTestConfig()).getRealizationsByTable("String_Node_Str", "String_Node_Str").contains(cube));
    ProjectManager.getInstance(getTestConfig()).updateRealizationToProject(RealizationType.CUBE, cube.getName(), "String_Node_Str", "String_Node_Str");
    assertTrue(ProjectManager.getInstance(this.getTestConfig()).getRealizationsByTable("String_Node_Str", "String_Node_Str").contains(cube));
}

Output:
     assertTrue(!ProjectManager.getInstance(this.getTestConfig()).getRealizationsByTable("String_Node_Str", "String_Node_Str").contains(cube));
-    ProjectManager.getInstance(getTestConfig()).updateRealizationToProject(RealizationType.CUBE, cube.getName(), "String_Node_Str", "String_Node_Str");
+    ProjectManager.getInstance(getTestConfig()).moveRealizationToProject(RealizationType.CUBE, cube.getName(), "String_Node_Str", "String_Node_Str");
     assertTrue(ProjectManager.getInstance(this.getTestConfig()).getRealizationsByTable("String_Node_Str", "String_Node_Str").contains(cube));


Input:
private AtlasEdge updateEdge(AtlasAttributeDef attributeDef, Object value, AtlasEdge currentEdge, final AtlasVertex entityVertex) throws AtlasBaseException {
    LOG.debug("String_Node_Str", attributeDef.getName());
    AtlasVertex currentVertex = currentEdge.getInVertex();
    String currentEntityId = AtlasGraphUtilsV1.getIdFromVertex(currentVertex);
    String newEntityId = getId(value);
    AtlasEdge newEdge = currentEdge;
    if (!currentEntityId.equals(newEntityId)) {
        if (entityVertex != null) {
            try {
                newEdge = graphHelper.getOrCreateEdge(currentEdge.getInVertex(), entityVertex, currentEdge.getLabel());
            } catch (RepositoryException e) {
                throw new AtlasBaseException(AtlasErrorCode.INTERNAL_ERROR, e);
            }
        }
    }
    return newEdge;
}

Output:
     String currentEntityId = AtlasGraphUtilsV1.getIdFromVertex(currentVertex);
-    String newEntityId = getId(value);
+    String newEntityId = AtlasGraphUtilsV1.getIdFromVertex(entityVertex);
     AtlasEdge newEdge = currentEdge;


Input:
private void editMaxExclusive() {
    XSDMaxExclusiveFacet currentValue = std.getMaxExclusiveFacet();
    String stringValue = "String_Node_Str";
    if (currentValue != null)
        stringValue = currentValue.getLexicalValue();
    dialog = new InputDialog(page.getSite().getShell(), "String_Node_Str", "String_Node_Str", stringValue == null ? "String_Node_Str" : stringValue, new IInputValidator() {
        public String isValid(String newText) {
            double val;
            try {
                val = Double.parseDouble(newText);
            } catch (Exception e) {
                return "String_Node_Str";
            }
            if (val < 0)
                return "String_Node_Str";
            return null;
        }
    });
    dialog.setBlockOnOpen(true);
    int ret = dialog.open();
    if (ret == Dialog.CANCEL)
        return;
    if (currentValue != null)
        std.getFacetContents().remove(currentValue);
    double intValue = Double.parseDouble(((InputDialog) dialog).getValue());
    if (intValue > 0) {
        XSDMaxExclusiveFacet f = (XSDSchemaBuildingTools.getXSDFactory()).createXSDMaxExclusiveFacet();
        f.setLexicalValue("String_Node_Str" + intValue);
        std.getFacetContents().add(f);
    }
}

Output:
         std.getFacetContents().remove(currentValue);
-    double intValue = Double.parseDouble(((InputDialog) dialog).getValue());
+    int intValue = Integer.parseInt(((InputDialog) dialog).getValue());
     if (intValue > 0) {


Input:
private static FileSystem createZipFileSystem(Path path, boolean create) throws IOException {
    final URI uri = URI.create("String_Node_Str" + path.toUri().getRawPath());
    final Map<String, String> env = new HashMap<>();
    if (create) {
        env.put("String_Node_Str", "String_Node_Str");
    }
    return FileSystems.newFileSystem(uri, env);
}

Output:
 private static FileSystem createZipFileSystem(Path path, boolean create) throws IOException {
-    final URI uri = URI.create("String_Node_Str" + path.toUri().getRawPath());
+    final URI uri = URI.create("String_Node_Str" + path.toUri());
     final Map<String, String> env = new HashMap<>();


Input:
public void initDragNDrop(FormController formController, int clientDesignYOffset) {
    this.yOffset = clientDesignYOffset;
    Form form = formController.getForm();
    if (form.getOnDragMethodID() > 0 || form.getOnDragEndMethodID() > 0 || form.getOnDragOverMethodID() > 0 || form.getOnDropMethodID() > 0) {
        this.dragNdropController = formController;
        final DragStartTester dragTester = new DragStartTester();
        addMouseMotionListener(dragTester);
        addMouseListener(dragTester);
        addContainerListener(new ContainerListener() {

            public void componentAdded(ContainerEvent e) {
                Component child = e.getChild();
                if (child instanceof JComponent) {
                    child.addMouseMotionListener(dragTester);
                    child.addMouseListener(dragTester);
                    if (child instanceof ISupportDragNDropTextTransfer)
                        ((ISupportDragNDropTextTransfer) child).clearTransferHandler();
                    else if (child instanceof DataComboBox)
                        ((DataComboBox) child).disableEditorTransferHandler();
                    else
                        ((JComponent) child).setTransferHandler(null);
                }
            }
            public void componentRemoved(ContainerEvent e) {
            }
        });
        setTransferHandler(FormDataTransferHandler.getInstance());
        new DropTarget(this, (DropTargetListener) FormDataTransferHandler.getInstance());
    }
}

Output:
 public void initDragNDrop(FormController formController, int clientDesignYOffset) {
-    this.yOffset = clientDesignYOffset;
-    Form form = formController.getForm();
-    if (form.getOnDragMethodID() > 0 || form.getOnDragEndMethodID() > 0 || form.getOnDragOverMethodID() > 0 || form.getOnDropMethodID() > 0) {
-        this.dragNdropController = formController;
-        final DragStartTester dragTester = new DragStartTester();
-        addMouseMotionListener(dragTester);
-        addMouseListener(dragTester);
-        addContainerListener(new ContainerListener() {
+    if (!GraphicsEnvironment.isHeadless()) {
+        this.yOffset = clientDesignYOffset;
+        Form form = formController.getForm();
+        if (form.getOnDragMethodID() > 0 || form.getOnDragEndMethodID() > 0 || form.getOnDragOverMethodID() > 0 || form.getOnDropMethodID() > 0) {
+            this.dragNdropController = formController;
+            final DragStartTester dragTester = new DragStartTester();
+            addMouseMotionListener(dragTester);
+            addMouseListener(dragTester);
+            addContainerListener(new ContainerListener() {


Input:
protected String getParamValueAsString(HttpServletRequest request, ScalarParameterHandle parameter) {
    String paramName = parameter.getName();
    String paramValue = null;
    if (ParameterAccessor.isReportParameterExist(request, paramName)) {
        paramValue = ParameterAccessor.getReportParameter(request, paramName, null);
    }
    if (paramValue != null)
        return paramValue;
    Object paramValueObj = null;
    if (isDesigner && (IBirtConstants.SERVLET_PATH_RUN.equalsIgnoreCase(request.getServletPath()) || IBirtConstants.SERVLET_PATH_PARAMETER.equalsIgnoreCase(request.getServletPath())) && this.configMap != null && this.configMap.containsKey(paramName)) {
        paramValueObj = this.configMap.get(paramName);
    } else if (this.parameterMap != null && this.parameterMap.containsKey(paramName)) {
        paramValueObj = this.parameterMap.get(paramName);
        paramValueObj = ParameterValidationUtil.getDisplayValue(null, parameter.getPattern(), paramValueObj, locale);
    }
    if (paramValueObj != null)
        paramValue = paramValueObj.toString();
    return paramValue;
}

Output:
     Object paramValueObj = null;
-    if (isDesigner && (IBirtConstants.SERVLET_PATH_RUN.equalsIgnoreCase(request.getServletPath()) || IBirtConstants.SERVLET_PATH_PARAMETER.equalsIgnoreCase(request.getServletPath())) && this.configMap != null && this.configMap.containsKey(paramName)) {
+    if (this.isDesigner && (IBirtConstants.SERVLET_PATH_RUN.equalsIgnoreCase(request.getServletPath()) || IBirtConstants.SERVLET_PATH_PARAMETER.equalsIgnoreCase(request.getServletPath())) && this.configMap != null && this.configMap.containsKey(paramName)) {
         paramValueObj = this.configMap.get(paramName);