Input:
protected void selectAction(int index) {
    if (!haveLocator() && allLabels == null)
        throw exception("String_Node_Str", index);
    if (allLabels != null) {
        selectFromList(allLabels.getWebElements(), index);
        return;
    }
    if (getLocator().toString().contains("String_Node_Str")) {
        new Clickable(fillByTemplate(getLocator(), index)).click();
        return;
    }
    List<WebElement> els = getDriver().findElements(getLocator());
    if (els.size() == 1)
        getSelector().selectByIndex(index);
    else
        selectFromList(els, index);
}

Output:
     }
-    List<WebElement> els = getDriver().findElements(getLocator());
+    List<WebElement> els = getAvatar().getElements();
     if (els.size() == 1)


Input:
public void syncUp(String clusterName) {
    StatusSyncUpRequest request = new StatusSyncUpRequest(clusterName, lockedEntityManager, softwareManagerCollector, this, WorkQueue.CUSTOM_FIVE_MIN_SYNC_DELAY);
    CmsWorker.addPeriodic(request);
    inQueueCluster.add(clusterName);
}

Output:
 public void syncUp(String clusterName) {
-    StatusSyncUpRequest request = new StatusSyncUpRequest(clusterName, lockedEntityManager, softwareManagerCollector, this, WorkQueue.CUSTOM_FIVE_MIN_SYNC_DELAY);
-    CmsWorker.addPeriodic(request);
-    inQueueCluster.add(clusterName);
+    requestQueue.add(clusterName);
 }


Input:
public void actionPerformed(ActionEvent actor) {
    String command = actor.getActionCommand();
    List<PossibleAction> actions = ((ActionTaker) actor.getSource()).getPossibleActions();
    PossibleAction executedAction = null;
    if (actions != null && actions.size() > 0) {
        executedAction = actions.get(0);
    }
    if (command.equals(BUY_CMD)) {
        process(executedAction);
    } else if (command.equals(SELL_CMD)) {
        process(executedAction);
    } else if (command.equals(DONE_CMD) || command.equals(PASS_CMD)) {
        if (GameManager.isGameOver()) {
            System.exit(0);
        }
        process(executedAction);
    } else if (command.equals(SWAP_CMD)) {
        SpecialSRProperty sp = (SpecialSRProperty) stockRound.getSpecialProperties().get(0);
        if (sp instanceof ExchangeForShare) {
            ((ExchangeForShare) sp).execute();
            extraButton.setText("String_Node_Str");
            extraButton.setEnabled(false);
            extraButton.setVisible(false);
        }
    } else if (command.equals(QUIT_CMD))
        System.exit(0);
    else if (command.equals(SAVE_CMD))
        new JFileChooser().showSaveDialog(this);
    else if (command.equals(REPORT_CMD)) {
        GameUILoader.reportWindow.setVisible(((JMenuItem) actor.getSource()).isSelected());
        return;
    } else if (command.equals(MARKET_CMD)) {
        GameUILoader.stockChart.setVisible(((JMenuItem) actor.getSource()).isSelected());
    } else if (command.equals(MAP_CMD)) {
        GameUILoader.orWindow.setVisible(((JMenuItem) actor.getSource()).isSelected());
    } else if (command.equals(UNDO_CMD)) {
        process(executedAction);
    } else if (command.equals(FORCED_UNDO_CMD)) {
        process(executedAction);
    } else if (command.equals(REDO_CMD)) {
        process(executedAction);
    }
}

Output:
     String command = actor.getActionCommand();
-    List<PossibleAction> actions = ((ActionTaker) actor.getSource()).getPossibleActions();
+    List<PossibleAction> actions = null;
+    if (actor.getSource() instanceof ActionTaker) {
+        actions = ((ActionTaker) actor.getSource()).getPossibleActions();
+    }
     PossibleAction executedAction = null;


Input:
public void checkSetup() {
    String regId = this.getCurrentToken();
    if (regId.isEmpty()) {
        this.registerInBackground();
    } else {
        if (!Utils.getInternalSettingBool(this, Const.GCM_REG_ID_SENT_TO_SERVER, false)) {
            this.sendRegistrationIdToBackend(regId);
        }
        this.checkRegisterIdUpdate(regId);
    }
}

Output:
     } else {
-        if (!Utils.getInternalSettingBool(this, Const.GCM_REG_ID_SENT_TO_SERVER, false)) {
+        if (!Utils.getInternalSettingBool(mContext, Const.GCM_REG_ID_SENT_TO_SERVER, false)) {
             this.sendRegistrationIdToBackend(regId);


Input:
private boolean displayProposals(final IJavaElement element, final SortedSet<Tuple<IMethodName, Double>> proposals) {
    if (proposals.isEmpty()) {
        return false;
    }
    if (calls != null) {
        calls.dispose();
        line.dispose();
        if (templates != null) {
            templates.dispose();
            line2.dispose();
        }
    }
    final String text = "String_Node_Str" + element.getElementName() + "String_Node_Str";
    line = new TextAndFeaturesLine(composite, text, element, element.getElementName(), this, server, new TemplateEditDialog(getShell()));
    line.createStyleRange(15, element.getElementName().length(), SWT.NORMAL, false, true);
    calls = SwtFactory.createGridComposite(composite, 3, 12, 2, 12, 0);
    for (final Tuple<IMethodName, Double> proposal : proposals) {
        SwtFactory.createSquare(calls);
        SwtFactory.createLabel(calls, Names.vm2srcSimpleMethod(proposal.getFirst()), false, false, true);
        SwtFactory.createLabel(calls, Math.round(proposal.getSecond() * 100) + "String_Node_Str", false, true, false);
    }
    composite.layout(true);
    return true;
}

Output:
         SwtFactory.createSquare(calls);
-        SwtFactory.createLabel(calls, Names.vm2srcSimpleMethod(proposal.getFirst()), false, false, true);
+        final IMethodName method = proposal.getFirst();
+        final String prefix = method.isInit() ? "String_Node_Str" : method.getDeclaringType().getClassName() + "String_Node_Str";
+        SwtFactory.createLabel(calls, prefix + Names.vm2srcSimpleMethod(method), false, false, true);
         SwtFactory.createLabel(calls, Math.round(proposal.getSecond() * 100) + "String_Node_Str", false, true, false);


Input:
private void rebuildShadowTree() {
    Map<Component, Integer> oldCacheMap = getIndexCacheMap();
    final boolean destroyCacheMap = oldCacheMap == null;
    try {
        if (destroyCacheMap)
            oldCacheMap = initIndexCacheMap();
        rebuildSubShadowTree();
    } finally {
        if (destroyCacheMap)
            destroyIndexCacheMap();
    }
}

Output:
         if (destroyCacheMap)
-            oldCacheMap = initIndexCacheMap();
+            initIndexCacheMap();
         rebuildSubShadowTree();


Input:
private List<VarConfig> decode(FgModel model, FgExamples data, DatasetType dataType, File predOut, String name) throws IOException, ParseException {
    log.info("String_Node_Str" + name + "String_Node_Str");
    SimpleAnnoSentenceCollection goldSents = (SimpleAnnoSentenceCollection) data.getSourceSentences();
    SimpleAnnoSentenceCollection predSents = new SimpleAnnoSentenceCollection();
    List<VarConfig> predictions = new ArrayList<VarConfig>();
    for (int i = 0; i < goldSents.size(); i++) {
        SimpleAnnoSentence goldSent = goldSents.get(i);
        SimpleAnnoSentence predSent = new SimpleAnnoSentence(goldSent);
        SrlDecoder decoder = getDecoder();
        decoder.decode(model, data.get(i));
        SrlGraph srlGraph = decoder.getSrlGraph();
        predSent.setSrlGraph(srlGraph);
        int[] parents = decoder.getParents();
        if (parents != null) {
            predSent.setParents(parents);
        }
        VarConfig vc = decoder.getMbrVarConfig();
        predictions.add(vc);
        predSents.add(predSent);
    }
    if (predOut != null) {
        log.info("String_Node_Str" + name + "String_Node_Str" + dataType + "String_Node_Str" + predOut);
        if (dataType == DatasetType.CONLL_2009) {
            CoNLL09Writer cw = new CoNLL09Writer(predOut);
            for (SimpleAnnoSentence sent : predSents) {
                CoNLL09Sentence conllSent = CoNLL09Sentence.fromSimpleAnnoSentence(sent);
                cw.write(conllSent);
            }
            cw.close();
        } else {
            throw new ParseException("String_Node_Str" + dataType);
        }
    }
    return predictions;
}

Output:
     SimpleAnnoSentenceCollection predSents = new SimpleAnnoSentenceCollection();
-    List<VarConfig> predictions = new ArrayList<VarConfig>();
+    List<VarConfig> predVcs = new ArrayList<VarConfig>();
+    List<VarConfig> goldVcs = new ArrayList<VarConfig>();
     for (int i = 0; i < goldSents.size(); i++) {


Input:
static Locale getLocale(OperationContext context, final ModelNode operation) throws OperationFailedException {
    if (!operation.hasDefined(LOCALE.getName())) {
        return null;
    }
    String unparsed = normalizeLocale(operation.get(LOCALE.getName()).asString());
    int len = unparsed.length();
    if (len != 2 && len != 5 && len < 7) {
        reportInvalidLocaleFormat(context, unparsed);
        return null;
    }
    char char0 = unparsed.charAt(0);
    char char1 = unparsed.charAt(1);
    if (char0 < 'a' || char0 > 'z' || char1 < 'a' || char1 > 'z') {
        reportInvalidLocaleFormat(context, unparsed);
        return null;
    }
    if (len == 2) {
        return new Locale(unparsed, "String_Node_Str");
    }
    if (!isLocaleSeparator(unparsed.charAt(2))) {
        reportInvalidLocaleFormat(context, unparsed);
        return null;
    }
    char char3 = unparsed.charAt(3);
    if (isLocaleSeparator(char3)) {
        return new Locale(unparsed.substring(0, 2), "String_Node_Str", unparsed.substring(4));
    }
    char char4 = unparsed.charAt(4);
    if (char3 < 'A' || char3 > 'Z' || char4 < 'A' || char4 > 'Z') {
        reportInvalidLocaleFormat(context, unparsed);
        return null;
    }
    if (len == 5) {
        return new Locale(unparsed.substring(0, 2), unparsed.substring(3));
    }
    if (!isLocaleSeparator(unparsed.charAt(5))) {
        reportInvalidLocaleFormat(context, unparsed);
        return null;
    }
    return new Locale(unparsed.substring(0, 2), unparsed.substring(3, 5), unparsed.substring(6));
}

Output:
 static Locale getLocale(OperationContext context, final ModelNode operation) throws OperationFailedException {
-    if (!operation.hasDefined(LOCALE.getName())) {
+    if (!operation.hasDefined(GlobalOperationAttributes.LOCALE.getName())) {
         return null;


Input:
private void rollback() throws IOException {
    IO.unzip(rollback, TEMP_DIRECTORY);
    List<File> backup = new ArrayList<File>();
    File backupConfig = new File(TEMP_DIRECTORY, BACKUP_CONFIG_FOLDER);
    for (File file : RESOURCES_CONFIG) {
        deleteRecursively(file);
        backup.add(new File(backupConfig, file.getName()));
    }
    File backupMap = new File(TEMP_DIRECTORY, BACKUP_MAP_FOLDER);
    for (File file : RESOURCES_MAP) {
        deleteRecursively(file);
        backup.add(new File(backupMap, file.getName()));
    }
    File dest = new File("String_Node_Str");
    for (File file : backup) {
        if (file.isDirectory()) {
            FileUtils.copyDirectoryToDirectory(file, dest);
        } else {
            FileUtils.copyFileToDirectory(file, dest);
        }
    }
    deleteRecursively(TEMP_DIRECTORY);
}

Output:
     File dest = new File("String_Node_Str");
-    for (File file : backup) {
-        if (file.isDirectory()) {
-            FileUtils.copyDirectoryToDirectory(file, dest);
-        } else {
-            FileUtils.copyFileToDirectory(file, dest);
+    try {
+        for (File file : backup) {
+            if (file.isDirectory()) {
+                FileUtils.copyDirectoryToDirectory(file, dest);
+            } else {
+                FileUtils.copyFileToDirectory(file, dest);
+            }
         }


Input:
public int getIndex(String uri, String localName) {
    if (null == localName) {
        return -1;
    }
    int index = 0;
    for (Attribute attribute : attributes) {
        QName testQName = new QName(uri, localName);
        if (attribute.getQName().equals(testQName)) {
            return index;
        }
        index++;
    }
    return -1;
}

Output:
     int index = 0;
-    for (Attribute attribute : attributes) {
+    for (Attribute attribute : attributes()) {
         QName testQName = new QName(uri, localName);


Input:
public void processResource(Query query) {
    CrawlerConsole.print("String_Node_Str" + query.getOriginalURL().toString());
    if (query.getResource().getContentMimeSubType().equals("String_Node_Str")) {
        String html = getCrawledHtml(query);
        String url = query.getOriginalURL().toString();
        String host = query.getHost();
        if (url.split("String_Node_Str").length < 4) {
            url = url + "String_Node_Str";
        }
        String baseUrl = url.substring(0, url.lastIndexOf('/') + 1);
        Document doc = Jsoup.parse(html, baseUrl);
        LinksExtractor extractor = new LinksExtractor(doc);
        Set<String> links = extractor.getInternalLinks(host);
        for (String link : links) {
            pool.addURL(link);
        }
        ContentExtractor contentExtractor = new ContentExtractor(doc);
        Page page = new Page(query.getOriginalURL().toString(), host);
        if (contentExtractor.hasMetaDescription()) {
            page.setDescription(contentExtractor.getMetaDescription());
        }
        if (contentExtractor.hasMetaKeywords()) {
            page.setKeywords(contentExtractor.getMetaKeywords());
        }
        if (contentExtractor.hasMetaCharset()) {
            page.setCharset(contentExtractor.getMetaCharset());
        }
        String bodyText = doc.body().text();
        String bodyHtml = doc.body().toString();
        BodyContent bodyContent = new BodyContent(page.getUrl(), bodyHtml, bodyText);
        DbConnector conn = new DbConnector();
        CrawledPageController controller = new CrawledPageController(conn.getConnection());
        controller.save(page, bodyContent);
    }
}

Output:
     CrawlerConsole.print("String_Node_Str" + query.getOriginalURL().toString());
-    if (query.getResource().getContentMimeSubType().equals("String_Node_Str")) {
-        String html = getCrawledHtml(query);
-        String url = query.getOriginalURL().toString();
-        String host = query.getHost();
-        if (url.split("String_Node_Str").length < 4) {
-            url = url + "String_Node_Str";
+    if (query.getResource().getContentMimeSubType() != null) {
+        if (query.getResource().getContentMimeSubType().contains("String_Node_Str")) {
+            String html = getCrawledHtml(query);
+            String url = query.getOriginalURL().toString();
+            String host = query.getHost();
+            if (url.split("String_Node_Str").length < 4) {
+                url = url + "String_Node_Str";
+            }
+            String baseUrl = url.substring(0, url.lastIndexOf('/') + 1);
+            Document doc = Jsoup.parse(html, baseUrl);
+            LinksExtractor extractor = new LinksExtractor(doc);
+            Set<String> links = extractor.getInternalLinks(host);
+            for (String link : links) {
+                pool.addURL(link);
+            }
+            ContentExtractor contentExtractor = new ContentExtractor(doc);
+            Page page = new Page(query.getOriginalURL().toString(), host);
+            if (contentExtractor.hasMetaDescription()) {
+                page.setDescription(contentExtractor.getMetaDescription());
+            }
+            if (contentExtractor.hasMetaKeywords()) {
+                page.setKeywords(contentExtractor.getMetaKeywords());
+            }
+            if (contentExtractor.hasMetaCharset()) {
+                page.setCharset(contentExtractor.getMetaCharset());
+            }
+            String bodyText = doc.body().text();
+            String bodyHtml = doc.body().toString();
+            BodyContent bodyContent = new BodyContent(page.getUrl(), bodyHtml, bodyText);
+            DbConnector conn = new DbConnector();
+            CrawledPageController controller = new CrawledPageController(conn.getConnection());
+            controller.save(page, bodyContent);
+        } else {
+            System.out.println(query.getResource().getContentMimeSubType());
         }


Input:
public boolean getIsRepairable(ItemStack toRepair, ItemStack repair) {
    if (repairMaterial instanceof ItemStack) {
        return repair.isItemEqual((ItemStack) repairMaterial) || super.getIsRepairable(toRepair, repair);
    }
    if (repairMaterial instanceof String) {
        return ItemStackUtility.isItemOreDictedAs(repair, (String) repairMaterial) || super.getIsRepairable(toRepair, repair);
    }
    return super.getIsRepairable(toRepair, repair);
}

Output:
 public boolean getIsRepairable(ItemStack toRepair, ItemStack repair) {
-    if (repairMaterial instanceof ItemStack) {
+    if (repairMaterial instanceof ItemStack && repair != null) {
         return repair.isItemEqual((ItemStack) repairMaterial) || super.getIsRepairable(toRepair, repair);


Input:
protected void init(File xmlFile) throws XMLStreamException, FileNotFoundException {
    InputStream input = null;
    if (xmlFile.exists()) {
        input = new FileInputStream(xmlFile);
        try {
            read(input);
        } finally {
            if (parser != null) {
                try {
                    parser.close();
                } catch (Exception ex) {
                }
            }
            if (input != null) {
                try {
                    input.close();
                } catch (Exception ex) {
                }
            }
        }
    }
}

Output:
             }
-            if (input != null) {
-                try {
-                    input.close();
-                } catch (Exception ex) {
-                }
+        }
+        if (input != null) {
+            try {
+                input.close();
+            } catch (Exception ex) {
             }


Input:
private void callFunction(Context context, String function, FunctionType concrete, List<Var> oList, List<Var> iList, Var priorityVal) throws UndefinedTypeException, UserException {
    ArrayList<Var> realIList = new ArrayList<Var>(iList.size());
    ArrayList<Var> derefVars = new ArrayList<Var>();
    ArrayList<Var> waitVars = new ArrayList<Var>();
    Context waitContext = null;
    assert (concrete.getInputs().size() == iList.size());
    for (int i = 0; i < iList.size(); i++) {
        Var input = iList.get(i);
        Type inputType = input.type();
        Type expType = concrete.getInputs().get(i);
        if (inputType.getImplType().equals(expType.getImplType())) {
            realIList.add(input);
        } else if (Types.isRefTo(inputType, expType)) {
            if (waitContext == null) {
                waitContext = new LocalContext(context);
            }
            Var derefed;
            derefed = waitContext.createAliasVariable(expType);
            waitVars.add(input);
            derefVars.add(derefed);
            realIList.add(derefed);
        } else if (Types.isUpdateableEquiv(inputType, expType)) {
            realIList.add(snapshotUpdateable(context, input));
        } else {
            throw new STCRuntimeError(context.getFileLine() + "String_Node_Str" + "String_Node_Str" + inputType.toString() + "String_Node_Str" + expType.toString());
        }
    }
    List<Var> usedVars = null;
    List<Var> keepOpen = null;
    if (waitContext != null) {
        FunctionContext fc = context.getFunctionContext();
        usedVars = new ArrayList<Var>();
        usedVars.addAll(iList);
        usedVars.addAll(oList);
        keepOpen = RefCounting.filterWriteRefcount(oList);
        backend.startWaitStatement(fc.constructName("String_Node_Str" + function), waitVars, usedVars, keepOpen, WaitMode.DATA_ONLY, false, TaskMode.LOCAL_CONTROL);
        assert (waitVars.size() == derefVars.size());
        for (int i = 0; i < waitVars.size(); i++) {
            Var derefVar = derefVars.get(i);
            varCreator.declare(derefVar);
            if (Types.isArrayRef(waitVars.get(i).type())) {
                backend.retrieveRef(derefVar, waitVars.get(i));
            } else {
                throw new STCRuntimeError("String_Node_Str" + "String_Node_Str" + derefVar);
            }
        }
    }
    backendFunctionCall(context, function, oList, realIList, priorityVal);
    if (waitContext != null) {
        backend.endWaitStatement(usedVars, keepOpen);
    }
}

Output:
         keepOpen = RefCounting.filterWriteRefcount(oList);
-        backend.startWaitStatement(fc.constructName("String_Node_Str" + function), waitVars, usedVars, keepOpen, WaitMode.DATA_ONLY, false, TaskMode.LOCAL_CONTROL);
+        backend.startWaitStatement(fc.constructName("String_Node_Str" + function), waitVars, usedVars, keepOpen, Arg.createVar(priorityVal), WaitMode.DATA_ONLY, false, TaskMode.LOCAL_CONTROL);
         assert (waitVars.size() == derefVars.size());


Input:
public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess world, BlockPos pos) {
    if (world.getBlockState(pos).getBlock() instanceof LogicSlabBlock) {
        TileEntity te = world.getTileEntity(pos);
        if (te instanceof LogicTileEntity) {
            LogicTileEntity logicTileEntity = (LogicTileEntity) te;
            EnumFacing side = logicTileEntity.getFacing().getSide();
            switch(side) {
                case DOWN:
                    return BLOCK_DOWN;
                case UP:
                    return BLOCK_UP;
                case NORTH:
                    return BLOCK_NORTH;
                case SOUTH:
                    return BLOCK_SOUTH;
                case WEST:
                    return BLOCK_WEST;
                case EAST:
                    return BLOCK_EAST;
            }
        }
    }
    return BLOCK_DOWN;
}

Output:
 public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess world, BlockPos pos) {
-    if (world.getBlockState(pos).getBlock() instanceof LogicSlabBlock) {
+    IBlockState blockState = world.getBlockState(pos);
+    if (blockState.getBlock() instanceof LogicSlabBlock) {
         TileEntity te = world.getTileEntity(pos);


Input:
protected void handleFileExpressionImage(String fileExpr, IImageContent imageContent) throws BirtException {
    String imageFile = "String_Node_Str";
    try {
        Object file = evaluate(fileExpr);
        if (file != null) {
            imageFile = file.toString();
        } else if (fileExpr != null && fileExpr.length() > 0) {
            imageFile = fileExpr;
        }
        handleFileImage(imageFile, imageContent);
    } catch (BirtException ex) {
        if (fileExpr != null && fileExpr.length() > 0) {
            handleFileImage(fileExpr, imageContent);
        }
        throw ex;
    }
}

Output:
     String imageFile = "String_Node_Str";
-    try {
-        Object file = evaluate(fileExpr);
-        if (file != null) {
-            imageFile = file.toString();
-        } else if (fileExpr != null && fileExpr.length() > 0) {
-            imageFile = fileExpr;
-        }
-        handleFileImage(imageFile, imageContent);
-    } catch (BirtException ex) {
-        if (fileExpr != null && fileExpr.length() > 0) {
-            handleFileImage(fileExpr, imageContent);
-        }
-        throw ex;
+    Object file = evaluate(fileExpr);
+    if (file != null) {
+        imageFile = file.toString();
+    } else if (fileExpr != null) {
+        imageFile = fileExpr.getValue();
     }


Input:
public boolean checkTrigger(GameEvent event, Game game) {
    UUID targetId = event.getTargetId();
    Permanent permanent = game.getPermanent(targetId);
    if (permanent.getCardType().contains(CardType.ARTIFACT)) {
        for (Effect effect : this.getEffects()) {
            effect.setTargetPointer(new FixedTarget(this));
        }
        return true;
    }
    return false;
}

Output:
         for (Effect effect : this.getEffects()) {
-            effect.setTargetPointer(new FixedTarget(this));
+            effect.setTargetPointer(new FixedTarget(permanent, game));
         }


Input:
protected void createEntityItems(TableEntityElement entityElement) {
    this.tableNode = getEntityManager().getModel();
    boolean isLookup = false;
    TableEntityPart tableEntityPart = getEntityManager().getEditPart();
    if (tableEntityPart != null && tableEntityPart.getParent() != null) {
        if (tableEntityPart.getParent() instanceof PigMapInputTablePart) {
            PigMapInputTablePart inputTablePart = (PigMapInputTablePart) tableEntityPart.getParent();
            Object model = inputTablePart.getModel();
            if (model != null && model instanceof InputTable) {
                isLookup = ((InputTable) model).isLookup();
            }
        } else if (tableEntityPart.getParent() instanceof PigMapOutputTablePart) {
            isLookup = true;
        }
    }
    if (isLookup) {
        expression = new ExpressionFigure();
        expression.setText(tableNode.getExpression());
        expression.setOpaque(false);
        entityElement.add(expression);
    }
    branchContent = new PigMapBranchContent(getEntityManager());
    entityElement.add(branchContent);
}

Output:
     branchContent = new PigMapBranchContent(getEntityManager());
-    entityElement.add(branchContent);
+    TreeBranch treeBranch = new TreeBranch(branchContent, !isRoot());
+    entityElement.add(treeBranch);
 }


Input:
public void testBlankExpression() {
    expectedException.expectMessage("String_Node_Str");
    expectedException.expect(IllegalArgumentException.class);
    adapter.adapt("String_Node_Str", asColumnFamily("String_Node_Str"));
}

Output:
 public void testBlankExpression() {
-    expectedException.expectMessage("String_Node_Str");
-    expectedException.expect(IllegalArgumentException.class);
-    adapter.adapt("String_Node_Str", asColumnFamily("String_Node_Str"));
+    HColumnDescriptor descriptor = adapter.adapt("String_Node_Str", asColumnFamily("String_Node_Str"));
+    Assert.assertEquals(Integer.MAX_VALUE, descriptor.getMaxVersions());
+    Assert.assertEquals("String_Node_Str", ColumnDescriptorAdapter.buildGarbageCollectionExpression(descriptor));
 }


Input:
public void shouldReturnCurrentPosition() throws Exception {
    Renderable squarePolygon = new SquarePolygon(2, 1, 10);
    assertEquals(2, squarePolygon.getPosition().getX());
    assertEquals(1, squarePolygon.getPosition().getY());
}

Output:
 public void shouldReturnCurrentPosition() throws Exception {
-    Renderable squarePolygon = new SquarePolygon(2, 1, 10);
-    assertEquals(2, squarePolygon.getPosition().getX());
-    assertEquals(1, squarePolygon.getPosition().getY());
+    Renderable squarePolygon = new SquarePolygon(2f, 1f, 10f);
+    assertEquals(2, squarePolygon.getPosition().getX(), 1);
+    assertEquals(1, squarePolygon.getPosition().getY(), 1);
 }


Input:
public void appendText(ChatLine text) {
    StyledText st = textoutput.getTextWidget();
    if (text == null || textoutput == null || st == null)
        return;
    int startRange = st.getText().length();
    StringBuffer sb = new StringBuffer();
    if (text.getOriginator() != null) {
        sb.append(createLineWithTimestamp(text.getOriginator().getName() + "String_Node_Str"));
        StyleRange sr = new StyleRange();
        sr.start = startRange;
        sr.length = sb.length();
        IUser lu = getLocalUser();
        if (lu != null && lu.getID().equals(text.getOriginator().getID())) {
            sr.foreground = meColor;
        } else {
            sr.foreground = otherColor;
        }
        st.append(sb.toString());
        st.setStyleRange(sr);
    }
    int beforeMessageIndex = st.getText().length();
    st.append(text.getText());
    if (text.getOriginator() == null) {
        StyleRange sr = new StyleRange();
        sr.start = beforeMessageIndex;
        sr.length = text.getText().length();
        sr.foreground = systemColor;
        st.setStyleRange(sr);
    }
    if (!text.isNoCRLF()) {
        st.append("String_Node_Str");
    }
    String t = st.getText();
    if (t == null)
        return;
    st.setSelection(t.length());
}

Output:
     int beforeMessageIndex = st.getText().length();
-    st.append(text.getText());
+    st.append(text.getText().trim());
     if (text.getOriginator() == null) {


Input:
public org.hl7.fhir.dstu2.model.HealthcareService.HealthcareServiceAvailableTimeComponent convertHealthcareServiceAvailableTimeComponent(org.hl7.fhir.dstu3.model.HealthcareService.HealthcareServiceAvailableTimeComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.HealthcareService.HealthcareServiceAvailableTimeComponent tgt = new org.hl7.fhir.dstu2.model.HealthcareService.HealthcareServiceAvailableTimeComponent();
    copyElement(src, tgt);
    for (org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.HealthcareService.DaysOfWeek> t : src.getDaysOfWeek()) tgt.addDaysOfWeek(convertDaysOfWeek(t.getValue()));
    tgt.setAllDay(src.getAllDay());
    tgt.setAvailableStartTime(src.getAvailableStartTime());
    tgt.setAvailableEndTime(src.getAvailableEndTime());
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.HealthcareService.HealthcareServiceAvailableTimeComponent convertHealthcareServiceAvailableTimeComponent(org.hl7.fhir.dstu3.model.HealthcareService.HealthcareServiceAvailableTimeComponent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
private File extractTemplate() throws MojoExecutionException {
    getLog().info("String_Node_Str");
    File template = new File(build.getOutputDirectory(), "String_Node_Str");
    URL url;
    try {
        URI uri = new URI(templateURI);
        url = getUrl(uri);
    } catch (Exception e) {
        throw new MojoExecutionException("String_Node_Str", e);
    }
    try {
        FileUtils.copyURLToFile(url, template);
    } catch (IOException e) {
        throw new MojoExecutionException("String_Node_Str" + template, e);
    }
    File outputDir = new File(build.getOutputDirectory(), "String_Node_Str");
    outputDir.mkdirs();
    try {
        ZipExtractor ze = new ZipExtractor(template);
        ze.extract(outputDir);
    } catch (IOException e) {
        throw new MojoExecutionException("String_Node_Str", e);
    }
    return outputDir;
}

Output:
     try {
-        ZipExtractor ze = new ZipExtractor(template);
-        ze.extract(outputDir);
-    } catch (IOException e) {
+        uri = new URI(templateURI);
+    } catch (URISyntaxException e) {
         throw new MojoExecutionException("String_Node_Str", e);


Input:
public synchronized CustomTxtEvent getNext(final ITmfContext context) {
    final ITmfContext savedContext = context.clone();
    final CustomTxtEvent event = parse(context);
    if (event != null) {
        updateAttributes(savedContext, event.getTimestamp());
        context.increaseRank();
    }
    return event;
}

Output:
 public synchronized CustomTxtEvent getNext(final ITmfContext context) {
-    final ITmfContext savedContext = context.clone();
+    final ITmfContext savedContext = new TmfContext(context.getLocation(), context.getRank());
     final CustomTxtEvent event = parse(context);


Input:
public static Map<String, HttpServlet> loadServlets(Module mod) {
    Element rootNode = mod.getConfig().getDocumentElement();
    NodeList servletTags = rootNode.getElementsByTagName("String_Node_Str");
    Map<String, HttpServlet> servletMap = new HashMap<String, HttpServlet>();
    for (int i = 0; i < servletTags.getLength(); i++) {
        Node node = servletTags.item(i);
        NodeList childNodes = node.getChildNodes();
        String name = "String_Node_Str", className = "String_Node_Str";
        for (int j = 0; j < childNodes.getLength(); j++) {
            Node childNode = childNodes.item(j);
            if ("String_Node_Str".equals(childNode.getNodeName()))
                name = childNode.getTextContent();
            else if ("String_Node_Str".equals(childNode.getNodeName()))
                className = childNode.getTextContent();
        }
        if (name.length() == 0 || className.length() == 0) {
            log.warn("String_Node_Str" + name + "String_Node_Str" + className + "String_Node_Str" + mod.getName());
            continue;
        }
        HttpServlet httpServlet = null;
        try {
            httpServlet = (HttpServlet) ModuleFactory.getModuleClassLoader(mod).loadClass(className).newInstance();
        } catch (ClassNotFoundException e) {
            log.warn("String_Node_Str" + name + "String_Node_Str" + mod.getName(), e);
            continue;
        } catch (IllegalAccessException e) {
            log.warn("String_Node_Str" + name + "String_Node_Str" + mod.getName(), e);
            continue;
        } catch (InstantiationException e) {
            log.warn("String_Node_Str" + name + "String_Node_Str" + mod.getName(), e);
            continue;
        }
        servletMap.put(name, httpServlet);
    }
    moduleServlets.put(mod, servletMap);
    return servletMap;
}

Output:
             Node childNode = childNodes.item(j);
-            if ("String_Node_Str".equals(childNode.getNodeName()))
-                name = childNode.getTextContent();
-            else if ("String_Node_Str".equals(childNode.getNodeName()))
-                className = childNode.getTextContent();
+            if ("String_Node_Str".equals(childNode.getNodeName())) {
+                if (childNode.getTextContent() != null)
+                    name = childNode.getTextContent().trim();
+            } else if ("String_Node_Str".equals(childNode.getNodeName())) {
+                if (childNode.getTextContent() != null)
+                    className = childNode.getTextContent().trim();
+            }
         }


Input:
public <T extends RevObject> Optional<T> call(Class<T> clazz) {
    final ObjectId resolvedObjectId;
    if (objectId == null) {
        Optional<ObjectId> parsed = command(RevParse.class).setRefSpec(refSpec).call();
        if (parsed.isPresent()) {
            resolvedObjectId = parsed.get();
        } else {
            resolvedObjectId = ObjectId.NULL;
        }
    } else {
        resolvedObjectId = objectId;
    }
    if (resolvedObjectId.isNull()) {
        return Optional.absent();
    }
    RevObject revObject;
    if (RevTree.EMPTY_TREE_ID.equals(resolvedObjectId)) {
        revObject = RevTree.EMPTY;
    } else {
        revObject = objectDatabase().get(resolvedObjectId, clazz);
    }
    Preconditions.checkArgument(clazz.isAssignableFrom(revObject.getClass()), "String_Node_Str", clazz.getName(), revObject.getClass().getName());
    return Optional.of(clazz.cast(revObject));
}

Output:
     if (objectId == null) {
-        Optional<ObjectId> parsed = command(RevParse.class).setRefSpec(refSpec).call();
+        Optional<ObjectId> parsed = command(RevParse.class).setSource(source).setRefSpec(refSpec).call();
         if (parsed.isPresent()) {


Input:
public void leaveCluster(String nodeName) {
    if (hasJoinedCluster()) {
        ScriptHelper leaveClusterScript = newScript("String_Node_Str").body.append(sudo(format("String_Node_Str", getRiakAdminCmd(), nodeName))).body.append(sudo(format("String_Node_Str", getRiakAdminCmd()))).body.append(sudo(format("String_Node_Str", getRiakAdminCmd()))).failOnNonZeroResultCode();
        if (!isRiakOnPath()) {
            Map<String, String> newPathVariable = ImmutableMap.of("String_Node_Str", sbinPath);
            log.warn("String_Node_Str", getShellEnvironment(), newPathVariable);
            leaveClusterScript.environmentVariablesReset(newPathVariable);
        }
        leaveClusterScript.execute();
        entity.setAttribute(RiakNode.RIAK_NODE_HAS_JOINED_CLUSTER, Boolean.FALSE);
    } else {
        log.warn("String_Node_Str", entity.getId());
    }
}

Output:
     if (hasJoinedCluster()) {
-        ScriptHelper leaveClusterScript = newScript("String_Node_Str").body.append(sudo(format("String_Node_Str", getRiakAdminCmd(), nodeName))).body.append(sudo(format("String_Node_Str", getRiakAdminCmd()))).body.append(sudo(format("String_Node_Str", getRiakAdminCmd()))).failOnNonZeroResultCode();
+        ScriptHelper leaveClusterScript = newScript("String_Node_Str").body.append(sudo(format("String_Node_Str", getRiakAdminCmd()))).body.append(sudo(format("String_Node_Str", getRiakAdminCmd()))).body.append(sudo(format("String_Node_Str", getRiakAdminCmd()))).failOnNonZeroResultCode();
         if (!isRiakOnPath()) {


Input:
public void flushVertexPropertyCache(SqlgGraph sqlgGraph, Map<SchemaTable, Pair<SortedSet<String>, Map<SqlgVertex, Map<String, Object>>>> schemaVertexPropertyCache) {
    Connection conn = sqlgGraph.tx().getConnection();
    for (SchemaTable schemaTable : schemaVertexPropertyCache.keySet()) {
        Pair<SortedSet<String>, Map<SqlgVertex, Map<String, Object>>> vertexKeysPropertyCache = schemaVertexPropertyCache.get(schemaTable);
        SortedSet<String> keys = vertexKeysPropertyCache.getLeft();
        Map<SqlgVertex, Map<String, Object>> vertexPropertyCache = vertexKeysPropertyCache.getRight();
        StringBuilder sql = new StringBuilder();
        sql.append("String_Node_Str");
        sql.append(maybeWrapInQoutes(schemaTable.getSchema()));
        sql.append("String_Node_Str");
        sql.append(maybeWrapInQoutes(SchemaManager.VERTEX_PREFIX + schemaTable.getTable()));
        sql.append("String_Node_Str");
        int count = 1;
        for (String key : keys) {
            sql.append(maybeWrapInQoutes(key));
            if (count++ < keys.size()) {
                sql.append("String_Node_Str");
            }
        }
        sql.append("String_Node_Str");
        count = 1;
        for (String key : keys) {
            sql.append("String_Node_Str");
            sql.append(maybeWrapInQoutes(key));
            if (count++ < keys.size()) {
                sql.append("String_Node_Str");
            }
        }
        sql.append("String_Node_Str");
        count = 1;
        for (SqlgVertex sqlgVertex : vertexPropertyCache.keySet()) {
            Map<String, Object> properties = vertexPropertyCache.get(sqlgVertex);
            sql.append("String_Node_Str");
            sql.append(sqlgVertex.id());
            sql.append("String_Node_Str");
            int countProperties = 1;
            for (String key : keys) {
                Object value = properties.get(key);
                if (value != null) {
                    PropertyType propertyType = PropertyType.from(value);
                    switch(propertyType) {
                        case BOOLEAN:
                            sql.append(value);
                            break;
                        case BYTE:
                            sql.append(value);
                            break;
                        case SHORT:
                            sql.append(value);
                            break;
                        case INTEGER:
                            sql.append(value);
                            break;
                        case LONG:
                            sql.append(value);
                            break;
                        case FLOAT:
                            sql.append(value);
                            break;
                        case DOUBLE:
                            sql.append(value);
                            break;
                        case STRING:
                            sql.append("String_Node_Str");
                            sql.append(value);
                            sql.append("String_Node_Str");
                            break;
                        case BOOLEAN_ARRAY:
                            break;
                        case BYTE_ARRAY:
                            break;
                        case SHORT_ARRAY:
                            break;
                        case INTEGER_ARRAY:
                            break;
                        case LONG_ARRAY:
                            break;
                        case FLOAT_ARRAY:
                            break;
                        case DOUBLE_ARRAY:
                            break;
                        case STRING_ARRAY:
                            break;
                        default:
                            throw new IllegalStateException("String_Node_Str" + propertyType.name());
                    }
                } else {
                    sql.append("String_Node_Str");
                }
                if (countProperties++ < keys.size()) {
                    sql.append("String_Node_Str");
                }
            }
            sql.append("String_Node_Str");
            if (count++ < vertexPropertyCache.size()) {
                sql.append("String_Node_Str");
            }
            sqlgVertex.reset();
        }
        sql.append("String_Node_Str");
        count = 1;
        for (String key : keys) {
            sql.append(maybeWrapInQoutes(key));
            if (count++ < keys.size()) {
                sql.append("String_Node_Str");
            }
        }
        sql.append("String_Node_Str");
        sql.append("String_Node_Str");
        if (logger.isDebugEnabled()) {
            logger.debug(sql.toString());
        }
        try (Statement statement = conn.createStatement()) {
            statement.execute(sql.toString());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

Output:
                 } else {
-                    sql.append("String_Node_Str");
+                    if (sqlgVertex.property(key).isPresent()) {
+                        sql.append("String_Node_Str");
+                        sql.append((Object) sqlgVertex.value(key));
+                        sql.append("String_Node_Str");
+                    } else {
+                        sql.append("String_Node_Str");
+                    }
                 }


Input:
private void handlePacket() throws IOException {
    Byte packetId = in.readByte();
    int x;
    byte y;
    int z;
    switch(packetId) {
        case 0x00:
            write(packetId);
            break;
        case 0x01:
            write(packetId);
            if (isServerTunnel) {
                player.setEntityId(in.readInt());
                write(player.getEntityId());
            } else {
                write(in.readInt());
            }
            write(in.readUTF());
            write(in.readUTF());
            write(in.readLong());
            write(in.readByte());
            break;
        case 0x02:
            String name = in.readUTF();
            if (isServerTunnel || player.setName(name)) {
                tunneler.setName(streamType + "String_Node_Str" + player.getName());
                write(packetId);
                write(name);
            }
            break;
        case 0x03:
            String message = in.readUTF();
            if (isServerTunnel && server.options.getBoolean("String_Node_Str")) {
                Matcher colorMatcher = COLOR_PATTERN.matcher(message);
                String cleanMessage = colorMatcher.replaceAll("String_Node_Str");
                Matcher messageMatcher = MESSAGE_PATTERN.matcher(cleanMessage);
                if (messageMatcher.find()) {
                    Player friend = server.findPlayerExact(messageMatcher.group(1));
                    if (friend != null) {
                        String color = "String_Node_Str";
                        String title = "String_Node_Str";
                        String format = server.options.get("String_Node_Str");
                        Group group = friend.getGroup();
                        if (group != null) {
                            color = group.getColor();
                            if (group.showTitle()) {
                                title = group.getName();
                                format = server.options.get("String_Node_Str");
                            }
                        }
                        try {
                            message = String.format(format, friend.getName(), title, color) + messageMatcher.group(2);
                        } catch (IllegalFormatException e) {
                            System.out.println("String_Node_Str");
                        }
                    }
                }
            }
            if (!isServerTunnel) {
                if (player.isMuted() && !message.startsWith("String_Node_Str") && !message.startsWith("String_Node_Str")) {
                    player.addMessage("String_Node_Str");
                    break;
                }
                if (player.parseCommand(message)) {
                    break;
                }
                if (player.localChat() && !message.startsWith("String_Node_Str") && !message.startsWith("String_Node_Str")) {
                    player.execute(LocalSayCommand.class, message);
                    break;
                }
            }
            write(packetId);
            write(message);
            break;
        case 0x04:
            write(packetId);
            copyNBytes(8);
            break;
        case 0x05:
            write(packetId);
            write(in.readInt());
            write(in.readShort());
            write(in.readShort());
            write(in.readShort());
            break;
        case 0x06:
            write(packetId);
            copyNBytes(12);
            break;
        case 0x07:
            int user = in.readInt();
            int target = in.readInt();
            Player targetPlayer = server.playerList.findPlayer(target);
            if (targetPlayer != null) {
                if (targetPlayer.godModeEnabled()) {
                    in.readBoolean();
                    break;
                }
            }
            write(packetId);
            write(user);
            write(target);
            write(in.readBoolean());
            break;
        case 0x08:
            write(packetId);
            copyNBytes(2);
            break;
        case 0x09:
            write(packetId);
            break;
        case 0x0a:
            write(packetId);
            copyNBytes(1);
            if (!inGame && !isServerTunnel) {
                player.sendMOTD();
                if (server.options.getBoolean("String_Node_Str")) {
                    player.execute(PlayerListCommand.class);
                }
                inGame = true;
            }
            break;
        case 0x0b:
            write(packetId);
            copyPlayerLocation();
            break;
        case 0x0c:
            write(packetId);
            copyNBytes(9);
            break;
        case 0x0d:
            write(packetId);
            copyPlayerLocation();
            copyNBytes(8);
            break;
        case 0x0e:
            if (!isServerTunnel) {
                if (player.getGroupId() < 0) {
                    skipNBytes(11);
                } else {
                    byte status = in.readByte();
                    x = in.readInt();
                    y = in.readByte();
                    z = in.readInt();
                    byte face = in.readByte();
                    if (!server.chests.isLocked(x, y, z) || player.isAdmin()) {
                        if (server.chests.isLocked(x, y, z) && status == BLOCK_DESTROYED_STATUS) {
                            server.chests.releaseLock(x, y, z);
                        }
                        write(packetId);
                        write(status);
                        write(x);
                        write(y);
                        write(z);
                        write(face);
                        if (player.instantDestroyEnabled()) {
                            packetFinished();
                            write(packetId);
                            write(BLOCK_DESTROYED_STATUS);
                            write(x);
                            write(y);
                            write(z);
                            write(face);
                        }
                        if (status == BLOCK_DESTROYED_STATUS) {
                            player.destroyedBlock();
                        }
                    }
                }
            } else {
                write(packetId);
                copyNBytes(11);
            }
            break;
        case 0x0f:
            x = in.readInt();
            y = in.readByte();
            z = in.readInt();
            final byte direction = in.readByte();
            final short dropItem = in.readShort();
            byte itemCount = 0;
            short uses = 0;
            if (dropItem != -1) {
                itemCount = in.readByte();
                uses = in.readShort();
            }
            boolean writePacket = true;
            boolean drop = false;
            if (isServerTunnel || server.chests.isChest(x, y, z)) {
            } else if ((player.getGroupId() < 0) || !server.blockFirewall.playerAllowed(player, dropItem)) {
                String badBlock = String.format(server.l.get("String_Node_Str"), player.getName(), Short.toString(dropItem));
                server.runCommand("String_Node_Str", badBlock);
                writePacket = false;
                drop = true;
            } else if (dropItem == 54) {
                int xPosition = x;
                byte yPosition = y;
                int zPosition = z;
                switch(direction) {
                    case 0:
                        --yPosition;
                        break;
                    case 1:
                        ++yPosition;
                        break;
                    case 2:
                        --zPosition;
                        break;
                    case 3:
                        ++zPosition;
                        break;
                    case 4:
                        --xPosition;
                        break;
                    case 5:
                        ++xPosition;
                        break;
                }
                Chest adjacentChest = server.chests.adjacentChest(xPosition, yPosition, zPosition);
                if (adjacentChest != null && !adjacentChest.isOpen() && !adjacentChest.ownedBy(player)) {
                    player.addMessage("String_Node_Str");
                    writePacket = false;
                    drop = true;
                } else {
                    player.placingChest(new Coordinate(xPosition, yPosition, zPosition));
                }
            }
            if (writePacket) {
                write(packetId);
                write(x);
                write(y);
                write(z);
                write(direction);
                write(dropItem);
                if (dropItem != -1) {
                    write(itemCount);
                    write(uses);
                    if (dropItem <= 94 && direction >= 0) {
                        player.placedBlock();
                    }
                }
                player.openingChest(x, y, z);
            } else if (drop) {
                write((byte) 0x0e);
                write((byte) 0x04);
                write(x);
                write(y);
                write(z);
                write(direction);
            }
            break;
        case 0x10:
            write(packetId);
            copyNBytes(2);
            break;
        case 0x11:
            write(packetId);
            copyNBytes(14);
            break;
        case 0x12:
            write(packetId);
            copyNBytes(5);
            break;
        case 0x13:
            write(packetId);
            write(in.readInt());
            write(in.readByte());
            break;
        case 0x14:
            write(packetId);
            write(in.readInt());
            write(in.readUTF());
            copyNBytes(16);
            break;
        case 0x15:
            if (player.getGroupId() < 0) {
                skipNBytes(24);
                break;
            }
            write(packetId);
            copyNBytes(24);
            break;
        case 0x16:
            write(packetId);
            copyNBytes(8);
            break;
        case 0x17:
            write(packetId);
            copyNBytes(17);
            break;
        case 0x18:
            write(packetId);
            write(in.readInt());
            write(in.readByte());
            write(in.readInt());
            write(in.readInt());
            write(in.readInt());
            write(in.readByte());
            write(in.readByte());
            copyUnknownBlob();
            break;
        case 0x19:
            write(packetId);
            write(in.readInt());
            write(in.readUTF());
            write(in.readInt());
            write(in.readInt());
            write(in.readInt());
            write(in.readInt());
            break;
        case 0x1b:
            write(packetId);
            copyNBytes(18);
            break;
        case 0x1c:
            write(packetId);
            copyNBytes(10);
            break;
        case 0x1d:
            write(packetId);
            copyNBytes(4);
            break;
        case 0x1e:
            write(packetId);
            copyNBytes(4);
            break;
        case 0x1f:
            write(packetId);
            copyNBytes(7);
            break;
        case 0x20:
            write(packetId);
            copyNBytes(6);
            break;
        case 0x21:
            write(packetId);
            copyNBytes(9);
            break;
        case 0x22:
            write(packetId);
            copyNBytes(18);
            break;
        case 0x26:
            write(packetId);
            copyNBytes(5);
            break;
        case 0x27:
            write(packetId);
            copyNBytes(8);
            break;
        case 0x28:
            write(packetId);
            write(in.readInt());
            copyUnknownBlob();
            break;
        case 0x32:
            write(packetId);
            copyNBytes(9);
            break;
        case 0x33:
            write(packetId);
            copyNBytes(13);
            int chunkSize = in.readInt();
            write(chunkSize);
            copyNBytes(chunkSize);
            break;
        case 0x34:
            write(packetId);
            copyNBytes(8);
            short arraySize = in.readShort();
            write(arraySize);
            copyNBytes(arraySize * 4);
            break;
        case 0x35:
            write(packetId);
            x = in.readInt();
            y = in.readByte();
            z = in.readInt();
            byte blockType = in.readByte();
            byte metadata = in.readByte();
            if (blockType == 54 && player.placedChest(x, y, z)) {
                lockChest(x, y, z);
                player.placingChest(null);
            }
            write(x);
            write(y);
            write(z);
            write(blockType);
            write(metadata);
            break;
        case 0x36:
            write(packetId);
            copyNBytes(12);
            break;
        case 0x3c:
            write(packetId);
            copyNBytes(28);
            int recordCount = in.readInt();
            write(recordCount);
            copyNBytes(recordCount * 3);
            break;
        case 0x46:
            write(packetId);
            copyNBytes(1);
            break;
        case 0x64:
            byte id = in.readByte();
            byte invtype = in.readByte();
            String typeString = in.readUTF();
            if (invtype == 0) {
                if (server.chests.canOpen(player, player.openedChest()) || player.isAdmin()) {
                    if (server.chests.isLocked(player.openedChest())) {
                        if (player.isAttemptingUnlock()) {
                            server.chests.unlock(player.openedChest());
                            player.setAttemptedAction(null);
                            player.addMessage("String_Node_Str");
                            typeString = "String_Node_Str";
                        } else {
                            typeString = server.chests.chestName(player.openedChest());
                        }
                    } else {
                        typeString = "String_Node_Str";
                        if (player.isAttemptLock()) {
                            lockChest(player.openedChest());
                            typeString = player.nextChestName();
                        }
                    }
                } else {
                    player.addMessage("String_Node_Str");
                    in.readByte();
                    break;
                }
            }
            write(packetId);
            write(id);
            write(invtype);
            write(typeString);
            write(in.readByte());
            break;
        case 0x65:
            write(packetId);
            write(in.readByte());
            break;
        case 0x66:
            byte typeFrom = in.readByte();
            short slotFrom = in.readShort();
            byte typeTo = in.readByte();
            short slotTo = in.readShort();
            if ((typeFrom < 0 && typeTo < 0) || player.getGroupId() >= 0) {
                write(packetId);
                write(typeFrom);
                write(slotFrom);
                write(typeTo);
                write(slotTo);
                short moveItem = in.readShort();
                write(moveItem);
                if (moveItem != -1) {
                    write(in.readByte());
                    write(in.readShort());
                }
            } else {
                short moveItem = in.readShort();
                if (moveItem != -1) {
                    in.readByte();
                    in.readShort();
                }
            }
            break;
        case 0x67:
            byte type67 = in.readByte();
            if (type67 < 0 || player.getGroupId() >= 0) {
                write(packetId);
                short slot = in.readShort();
                write(type67);
                write(slot);
                short setItem = in.readShort();
                write(setItem);
                if (setItem != -1) {
                    write(in.readByte());
                    write(in.readShort());
                }
            } else {
                in.readShort();
                short setItem = in.readShort();
                if (setItem != -1) {
                    in.readByte();
                    in.readShort();
                }
            }
            break;
        case 0x68:
            byte type = in.readByte();
            if (type < 0 || player.getGroupId() >= 0) {
                write(packetId);
                write(type);
                short count = in.readShort();
                write(count);
                for (int c = 0; c < count; ++c) {
                    short item = in.readShort();
                    write(item);
                    if (item != -1) {
                        write(in.readByte());
                        write(in.readShort());
                    }
                }
            } else {
                short count = in.readShort();
                for (int c = 0; c < count; ++c) {
                    short item = in.readShort();
                    if (item != -1) {
                        in.readByte();
                        in.readShort();
                    }
                }
            }
            break;
        case 0x69:
            write(packetId);
            write(in.readByte());
            write(in.readShort());
            write(in.readShort());
            break;
        case 0x6a:
            write(packetId);
            write(in.readByte());
            write(in.readShort());
            write(in.readByte());
            break;
        case (byte) 0x82:
            write(packetId);
            write(in.readInt());
            write(in.readShort());
            write(in.readInt());
            write(in.readUTF());
            write(in.readUTF());
            write(in.readUTF());
            write(in.readUTF());
            break;
        case (byte) 0xff:
            write(packetId);
            String reason = in.readUTF();
            write(reason);
            if (reason.startsWith("String_Node_Str")) {
                server.addRobot(player);
            }
            player.close();
            break;
        default:
            if (EXPENSIVE_DEBUG_LOGGING) {
                while (true) {
                    skipNBytes(1);
                    flushAll();
                }
            } else {
                throw new IOException("String_Node_Str" + streamType + "String_Node_Str" + Integer.toHexString(packetId) + "String_Node_Str" + player.getName());
            }
    }
    packetFinished();
}

Output:
             }
-            write(in.readUTF());
-            write(in.readUTF());
+            write(readUTF16());
             write(in.readLong());


Input:
public String toString() {
    return "String_Node_Str" + types + "String_Node_Str" + participations + "String_Node_Str" + moduleDefinition + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + types + "String_Node_Str" + participations + "String_Node_Str" + moduleDefinition + "String_Node_Str";
+    return "String_Node_Str" + types + "String_Node_Str" + participations + "String_Node_Str";
 }


Input:
public void ScrambleTableWithScalingTest2() throws VerdictDBException, SQLException {
    RelationStandardizer.resetItemID();
    String sql = "String_Node_Str";
    NonValidatingSQLParser sqlToRelation = new NonValidatingSQLParser();
    AbstractRelation relation = sqlToRelation.toRelation(sql);
    RelationStandardizer gen = new RelationStandardizer(staticMetaData);
    relation = gen.standardize((SelectQuery) relation);
    QueryExecutionPlan queryExecutionPlan = QueryExecutionPlanFactory.create("String_Node_Str", meta, (SelectQuery) relation);
    queryExecutionPlan.cleanUp();
    queryExecutionPlan = AsyncQueryExecutionPlan.create(queryExecutionPlan);
    ((AsyncAggExecutionNode) queryExecutionPlan.getRoot().getExecutableNodeBaseDependent(0).getExecutableNodeBaseDependent(0)).setScrambleMeta(meta);
    stmt.execute("String_Node_Str");
    JdbcConnection jdbcconn = new JdbcConnection(conn, new H2Syntax());
    ExecutablePlanRunner.runTillEnd(jdbcconn, queryExecutionPlan);
    jdbcconn.execute("String_Node_Str");
}

Output:
     queryExecutionPlan = AsyncQueryExecutionPlan.create(queryExecutionPlan);
-    ((AsyncAggExecutionNode) queryExecutionPlan.getRoot().getExecutableNodeBaseDependent(0).getExecutableNodeBaseDependent(0)).setScrambleMeta(meta);
+    ((AsyncAggExecutionNode) queryExecutionPlan.getRoot().getExecutableNodeBaseDependent(0).getExecutableNodeBaseDependent(0)).setScrambleMetaSet(meta);
     stmt.execute("String_Node_Str");


Input:
public void init(FMLInitializationEvent event) {
    versionInfo = VersionChecker.executeVersionCheck(REFERENCE.VERSION_UPDATE_FILE, REFERENCE.VERSION.equals("String_Node_Str") ? "String_Node_Str" : REFERENCE.VERSION);
    ModEventHandler eventHandler = new ModEventHandler();
    MinecraftForge.EVENT_BUS.register(eventHandler);
    MinecraftForge.TERRAIN_GEN_BUS.register(eventHandler);
    MinecraftForge.EVENT_BUS.register(new ModPlayerEventHandler());
    MinecraftForge.EVENT_BUS.register(new ModEntityEventHandler());
    GameRegistry.registerWorldGenerator(new VampirismWorldGen(), 1000);
    HelperRegistry.registerPlayerEventReceivingCapability(VampirePlayer.CAP, VampirePlayer.class);
    HelperRegistry.registerPlayerEventReceivingCapability(HunterPlayer.CAP, HunterPlayer.class);
    HelperRegistry.registerSyncableEntityCapability(ExtendedCreature.CAP, REFERENCE.EXTENDED_CREATURE_KEY, ExtendedCreature.class);
    HelperRegistry.registerSyncablePlayerCapability(VampirePlayer.CAP, REFERENCE.VAMPIRE_PLAYER_KEY, VampirePlayer.class);
    HelperRegistry.registerSyncablePlayerCapability(HunterPlayer.CAP, REFERENCE.HUNTER_PLAYER_KEY, HunterPlayer.class);
    HelperRegistry.registerSyncablePlayerCapability(FactionPlayerHandler.CAP, REFERENCE.FACTION_PLAYER_HANDLER_KEY, FactionPlayerHandler.class);
    Achievements.registerAchievement();
    SupporterManager.getInstance().initAsync();
    BloodPotions.register();
    proxy.onInitStep(IInitListener.Step.INIT, event);
    modCompatLoader.onInitStep(IInitListener.Step.INIT, event);
}

Output:
 public void init(FMLInitializationEvent event) {
-    versionInfo = VersionChecker.executeVersionCheck(REFERENCE.VERSION_UPDATE_FILE, REFERENCE.VERSION.equals("String_Node_Str") ? "String_Node_Str" : REFERENCE.VERSION);
+    versionInfo = VersionChecker.executeVersionCheck(REFERENCE.VERSION_UPDATE_FILE, "String_Node_Str".equals(REFERENCE.VERSION) ? "String_Node_Str" : REFERENCE.VERSION);
     ModEventHandler eventHandler = new ModEventHandler();


Input:
public void process(ReadableArchive readableArchive, WebBundleDescriptor webBundleDesc, ClassLoader classLoader, Parser parser) throws IOException {
    this.archiveFile = new File(readableArchive.getURI());
    this.classLoader = classLoader;
    if (parser == null) {
        ParsingContext.Builder builder = new ParsingContext.Builder();
        builder.logger(logger);
        ParsingContext pc = builder.build();
        parser = new Parser(pc);
    }
    this.classParser = parser;
    if (AnnotationUtils.getLogger().isLoggable(Level.FINE)) {
        AnnotationUtils.getLogger().fine("String_Node_Str" + archiveFile);
        AnnotationUtils.getLogger().fine("String_Node_Str" + webBundleDesc);
        AnnotationUtils.getLogger().fine("String_Node_Str" + classLoader);
    }
    if (!archiveFile.isDirectory()) {
        return;
    }
    if (isScanOtherLibraries()) {
        addLibraryJars(webBundleDesc, readableArchive);
        calculateResults();
        return;
    }
    File webinf = new File(archiveFile, "String_Node_Str");
    if (webBundleDesc instanceof WebFragmentDescriptor) {
        WebFragmentDescriptor webFragmentDesc = (WebFragmentDescriptor) webBundleDesc;
        File lib = new File(webinf, "String_Node_Str");
        if (lib.exists()) {
            File jarFile = new File(lib, webFragmentDesc.getJarName());
            if (jarFile.exists()) {
                if (jarFile.isDirectory()) {
                    addScanDirectory(jarFile);
                } else {
                    addScanJar(jarFile);
                }
            }
        }
    } else {
        File classes = new File(webinf, "String_Node_Str");
        if (classes.exists()) {
            addScanDirectory(classes);
        }
        scanXmlDefinedClassesIfNecessary(webBundleDesc);
    }
    calculateResults();
}

Output:
     this.classLoader = classLoader;
-    if (parser == null) {
-        ParsingContext.Builder builder = new ParsingContext.Builder();
-        builder.logger(logger);
-        ParsingContext pc = builder.build();
-        parser = new Parser(pc);
-    }
-    this.classParser = parser;
+    setParser(parser);
     if (AnnotationUtils.getLogger().isLoggable(Level.FINE)) {


Input:
public boolean hasCompleted() {
    return (rs != null);
}

Output:
 public boolean hasCompleted() {
-    return (rs != null);
+    return (json != null);
 }


Input:
protected void a() {
    super.a();
    this.datawatcher.a(16, 0);
    this.datawatcher.a(12, 0);
}

Output:
     super.a();
-    this.datawatcher.a(16, 0);
-    this.datawatcher.a(12, 0);
+    this.datawatcher.a(16, new Integer(0));
+    this.datawatcher.a(12, new Integer(0));
 }


Input:
public void zoomReset() {
    JCanvas canvas = _jgraph.getGraphPane().getCanvas();
    AffineTransform current = canvas.getCanvasPane().getTransformContext().getTransform();
    current.setToIdentity();
    canvas.getCanvasPane().setTransform(current);
    _graphPanner.repaint();
}

Output:
     canvas.getCanvasPane().setTransform(current);
-    _graphPanner.repaint();
+    if (_graphPanner != null) {
+        _graphPanner.repaint();
+    }
 }


Input:
public void setEmailAddress(String address) {
    if (address == null) {
        System.out.println("String_Node_Str");
        return;
    } else if (address.length() < 5) {
        System.out.println("String_Node_Str");
        return;
    } else if (!address.contains("String_Node_Str")) {
        System.out.println("String_Node_Str" + address + "String_Node_Str");
        address += "String_Node_Str";
    }
    System.out.println("String_Node_Str" + address);
    address = address.trim();
    String temp = address.substring(0, address.indexOf("String_Node_Str"));
    temp = temp.replace("String_Node_Str", "String_Node_Str");
    temp = temp.replace("String_Node_Str", "String_Node_Str");
    temp = temp.replace("String_Node_Str", "String_Node_Str");
    address = temp + address.substring(address.indexOf("String_Node_Str"));
    System.out.println("String_Node_Str" + address);
    completeAddress = address;
}

Output:
         System.out.println("String_Node_Str" + address + "String_Node_Str");
-        address += "String_Node_Str";
+        address += getCarrierExtension("String_Node_Str");
     }


Input:
protected void setupDatabase(Database database) throws Exception {
    dropAndCreateTable(new CreateTableStatement(TABLE_NAME).addColumn(COLUMN_NAME, "String_Node_Str", new NotNullConstraint()).addColumn(COLUMN2_NAME, "String_Node_Str", new NotNullConstraint()), database);
    dropAndCreateTable(new CreateTableStatement(TestContext.ALT_SCHEMA, TABLE_NAME).addColumn(COLUMN_NAME, "String_Node_Str", new NotNullConstraint()).addColumn(COLUMN2_NAME, "String_Node_Str", new NotNullConstraint()), database);
}

Output:
 protected void setupDatabase(Database database) throws Exception {
-    dropAndCreateTable(new CreateTableStatement(TABLE_NAME).addColumn(COLUMN_NAME, "String_Node_Str", new NotNullConstraint()).addColumn(COLUMN2_NAME, "String_Node_Str", new NotNullConstraint()), database);
+    dropAndCreateTable(new CreateTableStatement(null, TABLE_NAME).addColumn(COLUMN_NAME, "String_Node_Str", new NotNullConstraint()).addColumn(COLUMN2_NAME, "String_Node_Str", new NotNullConstraint()), database);
     dropAndCreateTable(new CreateTableStatement(TestContext.ALT_SCHEMA, TABLE_NAME).addColumn(COLUMN_NAME, "String_Node_Str", new NotNullConstraint()).addColumn(COLUMN2_NAME, "String_Node_Str", new NotNullConstraint()), database);


Input:
public static void setNbt(EntityVillager villager, NBTTagCompound nbt) {
    setName(villager, nbt);
    nbt.setInteger("String_Node_Str", villager.getProfession());
    MerchantRecipeList recipes = villager.getRecipes(null);
    MerchantRecipe recipe;
    NBTTagCompound recipeTag;
    for (int i = 0; i < recipes.size(); i++) {
        recipe = (MerchantRecipe) recipes.get(i);
        recipeTag = recipe.writeToTags();
        recipeTag.setInteger("String_Node_Str", 0);
        recipeTag.setInteger("String_Node_Str", 7);
        recipe.readFromTags(recipeTag);
    }
    nbt.setTag("String_Node_Str", recipes.getRecipiesAsTags());
}

Output:
     MerchantRecipeList recipes = villager.getRecipes(null);
-    MerchantRecipe recipe;
-    NBTTagCompound recipeTag;
-    for (int i = 0; i < recipes.size(); i++) {
-        recipe = (MerchantRecipe) recipes.get(i);
-        recipeTag = recipe.writeToTags();
-        recipeTag.setInteger("String_Node_Str", 0);
-        recipeTag.setInteger("String_Node_Str", 7);
-        recipe.readFromTags(recipeTag);
+    if (recipes != null) {
+        MerchantRecipe recipe;
+        NBTTagCompound recipeTag;
+        for (int i = 0; i < recipes.size(); i++) {
+            recipe = (MerchantRecipe) recipes.get(i);
+            recipeTag = recipe.writeToTags();
+            recipeTag.setInteger("String_Node_Str", 0);
+            recipeTag.setInteger("String_Node_Str", 7);
+            recipe.readFromTags(recipeTag);
+        }
+        nbt.setTag("String_Node_Str", recipes.getRecipiesAsTags());
     }


Input:
public void populateItem(final Item<ICellPopulator<ConfigurationTO>> cellItem, final String componentId, final IModel<ConfigurationTO> model) {
    final ConfigurationTO configurationTO = model.getObject();
    AjaxLink editLink = new IndicatingAjaxLink("String_Node_Str") {

        private static final long serialVersionUID = -7978723352517770644L;
        public void onClick(final AjaxRequestTarget target) {
            editConfigWin.setPageCreator(new ModalWindow.PageCreator() {
                private static final long serialVersionUID = -7834632442532690940L;
                public Page createPage() {
                    return new ConfigurationModalPage(Configuration.this.getPageReference(), editConfigWin, configurationTO, false);
                }
            });
            editConfigWin.show(target);
        }
    };
    EditLinkPanel panel = new EditLinkPanel(componentId, model);
    panel.add(editLink);
    MetaDataRoleAuthorizationStrategy.authorize(panel, ENABLE, xmlRolesReader.getAllAllowedRoles("String_Node_Str", "String_Node_Str"));
    cellItem.add(panel);
}

Output:
     final ConfigurationTO configurationTO = model.getObject();
-    AjaxLink editLink = new IndicatingAjaxLink("String_Node_Str") {
+    final ActionLinksPanel panel = new ActionLinksPanel(componentId, model);
+    panel.add(new ActionLink() {


Input:
private void init(UserRequest ureq) {
    configurationCtrl = new IQConfigurationController(ureq, getWindowControl(), stackPanel, course, courseNode, type);
    listenTo(configurationCtrl);
    layoutConfigurationCtrl = new IQLayoutConfigurationController(ureq, getWindowControl(), course, courseNode, type);
    listenTo(layoutConfigurationCtrl);
    highScoreNodeConfigController = new HighScoreEditController(ureq, getWindowControl(), courseNode);
    listenTo(highScoreNodeConfigController);
    Condition accessCondition = courseNode.getPreConditionAccess();
    accessibilityCondContr = new ConditionEditController(ureq, getWindowControl(), euce, accessCondition, AssessmentHelper.getAssessableNodes(course.getEditorTreeModel(), courseNode));
    listenTo(accessibilityCondContr);
}

Output:
     listenTo(layoutConfigurationCtrl);
-    highScoreNodeConfigController = new HighScoreEditController(ureq, getWindowControl(), courseNode);
-    listenTo(highScoreNodeConfigController);
+    if (AssessmentInstance.QMD_ENTRY_TYPE_ASSESS.equals(type)) {
+        highScoreNodeConfigController = new HighScoreEditController(ureq, getWindowControl(), moduleConfiguration);
+        listenTo(highScoreNodeConfigController);
+    }
     Condition accessCondition = courseNode.getPreConditionAccess();


Input:
private void addTooltipContainer() {
    final JEditorPane cardInfoPane = (JEditorPane) Plugins.getInstance().getCardInfoPane();
    if (cardInfoPane == null) {
        return;
    }
    cardInfoPane.setSize(Constants.TOOLTIP_WIDTH_MIN, Constants.TOOLTIP_HEIGHT_MIN);
    cardInfoPane.setLocation(40, 40);
    cardInfoPane.setBackground(new Color(0, 0, 0, 0));
    MageRoundPane popupContainer = new MageRoundPane();
    popupContainer.setLayout(null);
    popupContainer.add(cardInfoPane);
    popupContainer.setVisible(false);
    popupContainer.setBounds(0, 0, Constants.TOOLTIP_WIDTH_MIN + Constants.TOOLTIP_BORDER_WIDTH, Constants.TOOLTIP_HEIGHT_MIN + Constants.TOOLTIP_BORDER_WIDTH);
    desktopPane.add(popupContainer, JLayeredPane.POPUP_LAYER);
    ui.addComponent(MageComponents.CARD_INFO_PANE, cardInfoPane);
    ui.addComponent(MageComponents.POPUP_CONTAINER, popupContainer);
    JPanel cardPreviewContainer = new JPanel();
    cardPreviewContainer.setOpaque(false);
    cardPreviewContainer.setLayout(null);
    BigCard bigCard = new BigCard();
    bigCard.setSize(320, 500);
    bigCard.setLocation(40, 40);
    bigCard.setBackground(new Color(0, 0, 0, 0));
    cardPreviewContainer.add(bigCard);
    cardPreviewContainer.setVisible(false);
    cardPreviewContainer.setBounds(0, 0, 320 + 80, 500 + 30);
    ui.addComponent(MageComponents.CARD_PREVIEW_PANE, bigCard);
    ui.addComponent(MageComponents.CARD_PREVIEW_CONTAINER, cardPreviewContainer);
    desktopPane.add(cardPreviewContainer, JLayeredPane.POPUP_LAYER);
    JPanel cardPreviewContainerRotated = new JPanel();
    cardPreviewContainerRotated.setOpaque(false);
    cardPreviewContainerRotated.setLayout(null);
    bigCard = new BigCard(true);
    bigCard.setSize(500, 350);
    bigCard.setLocation(40, 40);
    bigCard.setBackground(new Color(0, 0, 0, 0));
    cardPreviewContainerRotated.add(bigCard);
    cardPreviewContainerRotated.setVisible(false);
    cardPreviewContainerRotated.setBounds(0, 0, 500 + 80, 420 + 30);
    ui.addComponent(MageComponents.CARD_PREVIEW_PANE_ROTATED, bigCard);
    ui.addComponent(MageComponents.CARD_PREVIEW_CONTAINER_ROTATED, cardPreviewContainerRotated);
    desktopPane.add(cardPreviewContainerRotated, JLayeredPane.POPUP_LAYER);
}

Output:
     desktopPane.add(popupContainer, JLayeredPane.POPUP_LAYER);
-    ui.addComponent(MageComponents.CARD_INFO_PANE, cardInfoPane);
-    ui.addComponent(MageComponents.POPUP_CONTAINER, popupContainer);
+    UI.addComponent(MageComponents.CARD_INFO_PANE, cardInfoPane);
+    UI.addComponent(MageComponents.POPUP_CONTAINER, popupContainer);
     JPanel cardPreviewContainer = new JPanel();


Input:
public void activateEditor(IWorkbenchPage aPage, IStructuredSelection selection) {
    initOpenAction();
    openAction.selectionChanged(selection);
    openAction.run();
}

Output:
     openAction.selectionChanged(selection);
-    openAction.run();
+    for (IEditorPart editor : PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getEditors()) {
+        if (editor instanceof XObjectEditor2) {
+            if (selection.getFirstElement() == ((XObjectEditorInput2) editor.getEditorInput()).getViewObject()) {
+                PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().bringToTop(editor);
+            }
+        }
+        if (editor instanceof XSDEditor2) {
+            if (selection.getFirstElement() == ((XSDEditorInput2) editor.getEditorInput()).getViewObject()) {
+                PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().bringToTop(editor);
+            }
+        }
+    }
 }


Input:
private void primeScanner(final long startTileId, final long endTileId) {
    try {
        curPartition = -1;
        int partition = reader.getPartition(new TileIdWritable(startTileId));
        TileIdWritable startKey = null;
        while (curPartition == -1 && partition < reader.getMaxPartitions()) {
            if (!reader.canBeCached() && mapfile != null) {
                mapfile.close();
            }
            mapfile = reader.getReader(partition);
            try {
                if (startKey == null) {
                    startKey = (TileIdWritable) mapfile.getKeyClass().newInstance();
                    startKey.set(startTileId);
                    endKey = (TileIdWritable) mapfile.getKeyClass().newInstance();
                    endKey.set(endTileId);
                    currentValue = (TWritable) mapfile.getValueClass().newInstance();
                }
            } catch (InstantiationException e) {
                throw new MrsImageException(e);
            } catch (IllegalAccessException e) {
                throw new MrsImageException(e);
            }
            currentKey = (TileIdWritable) mapfile.getClosest(startKey, currentValue);
            if (currentKey != null && inRange(currentKey)) {
                readFirstKey = true;
                curPartition = partition;
            } else {
                partition++;
            }
        }
    } catch (Splits.SplitException se) {
        currentKey = null;
    } catch (final IOException e) {
        throw new MrsImageException(e);
    }
}

Output:
     try {
-        curPartition = -1;
-        int partition = reader.getPartition(new TileIdWritable(startTileId));
+        curPartitionIndex = -1;
+        int partitionIndex = reader.getPartitionIndex(new TileIdWritable(startTileId));
         TileIdWritable startKey = null;


Input:
public boolean handleFetch(IDataSetInstanceHandle dataSet, IDataRow row) {
    try {
        if (!useFetchEventHandler) {
            ScriptStatus status = handleJS(getScriptScope(dataSet), dataSet.getName(), FETCH, this.fetchScript);
            if (status.didRun()) {
                Object result = status.result();
                if (result instanceof Boolean)
                    return ((Boolean) result).booleanValue();
                else
                    throw new DataException(ResourceConstants.EXPECT_BOOLEAN_RETURN_TYPE, new Object[] { "String_Node_Str", result });
            }
        }
        if (scriptedEventHandler != null)
            return scriptedEventHandler.fetch(new DataSetInstance(dataSet), new UpdatableDataSetRow(row));
    } catch (Exception e) {
        addException(context, e);
    }
    return false;
}

Output:
         if (!useFetchEventHandler) {
-            ScriptStatus status = handleJS(getScriptScope(dataSet), dataSet.getName(), FETCH, this.fetchScript);
+            ScriptStatus status = handleJS(getScriptScope(dataSet), dataSet.getName(), FETCH, this.fetchScript, fetchMethodID);
             if (status.didRun()) {


Input:
private void drawGraph(Stock stock) {
    if (stock.getHistoricalData() == null) {
        return;
    }
    lineChart.setVisibility(View.VISIBLE);
    int index = stock.getHistoricalData().size() - 1;
    Entry[] entries = new Entry[index + 1];
    HashMap<Integer, String> xAxisValueToTextMap = new HashMap<>();
    String key = stock.getLastUpdatedDate();
    while (index >= 0) {
        if (stock.getHistoricalData().containsKey(key)) {
            entries[index] = new Entry(index, stock.getHistoricalData().get(key).floatValue());
            xAxisValueToTextMap.put(index, key);
            index--;
        }
        Date date = DateUtils.convertStringToDate(key);
        date.setTime(date.getTime() - 2);
        key = DateUtils.convertDateToString(date);
    }
    Description description = new Description();
    description.setText(StringUtils.getString(R.string.stock_history));
    lineChart.setDescription(description);
    LineDataSet lineDataSet = new LineDataSet(Arrays.asList(entries), StringUtils.getString(R.string.stock_price));
    lineChart.getAxisRight().setEnabled(false);
    lineChart.getXAxis().setValueFormatter((value, axis) -> {
        Timber.d("String_Node_Str" + value + "String_Node_Str" + xAxisValueToTextMap.get((int) value));
        return xAxisValueToTextMap.get((int) value);
    });
    lineDataSet.setMode(LineDataSet.Mode.CUBIC_BEZIER);
    lineDataSet.setCubicIntensity(0.2f);
    lineDataSet.setDrawCircles(false);
    lineDataSet.setLineWidth(1.8f);
    lineDataSet.setCircleRadius(4f);
    lineDataSet.setCircleColor(Color.WHITE);
    lineDataSet.setHighLightColor(Color.rgb(244, 117, 117));
    lineDataSet.setColor(Color.WHITE);
    lineDataSet.setFillColor(Color.WHITE);
    lineDataSet.setFillAlpha(100);
    lineDataSet.setDrawHorizontalHighlightIndicator(false);
    lineDataSet.setFillFormatter(new IFillFormatter() {
        public float getFillLinePosition(ILineDataSet dataSet, LineDataProvider dataProvider) {
            return -10;
        }
    });
    LineData data = new LineData(lineDataSet);
    data.setValueTextSize(9f);
    data.setDrawValues(false);
    lineChart.setData(data);
    lineChart.setMaxVisibleValueCount(10);
    lineChart.setVisibleXRangeMaximum(10);
    lineChart.moveViewToX(100);
    lineChart.setScaleX(1);
    lineDataSet.setColor(ContextCompat.getColor(StockTrackerApp.getContext(), R.color.colorPrimary));
}

Output:
 private void drawGraph(Stock stock) {
-    if (stock.getHistoricalData() == null) {
+    if (stock.getHistoricalData() == null || stock.getHistoricalData().size() == 0 || lineChart == null) {
         return;


Input:
public List<Problem> getProblems(INode node, IElement element) {
    List<Problem> toReturn = new ArrayList<Problem>();
    List<ModuleNeeded> list = node.getComponent().getModulesNeeded();
    List<ModuleNeeded> modulesNeeded = ModulesNeededProvider.getModulesNeeded();
    for (ModuleNeeded module : modulesNeeded) {
        for (ModuleNeeded current : list) {
            if (current.getContext().equals(module.getContext()) && current.getModuleName().equals(module.getModuleName())) {
                if (module.getStatus() == ELibraryInstallStatus.NOT_INSTALLED && current.isRequired()) {
                    Problem problem = new Problem(element, "String_Node_Str" + current.getModuleName() + "String_Node_Str", ProblemStatus.ERROR);
                    problem.setKey("String_Node_Str" + current.getModuleName());
                    toReturn.add(problem);
                }
            }
        }
    }
    return toReturn;
}

Output:
     List<ModuleNeeded> modulesNeeded = ModulesNeededProvider.getModulesNeeded();
-    for (ModuleNeeded module : modulesNeeded) {
-        for (ModuleNeeded current : list) {
-            if (current.getContext().equals(module.getContext()) && current.getModuleName().equals(module.getModuleName())) {
-                if (module.getStatus() == ELibraryInstallStatus.NOT_INSTALLED && current.isRequired()) {
-                    Problem problem = new Problem(element, "String_Node_Str" + current.getModuleName() + "String_Node_Str", ProblemStatus.ERROR);
-                    problem.setKey("String_Node_Str" + current.getModuleName());
-                    toReturn.add(problem);
+    boolean flag = false;
+    for (ModuleNeeded current : list) {
+        if (current.getRequiredIf() != null && !current.getRequiredIf().equals("String_Node_Str")) {
+            flag = true;
+        }
+    }
+    if (flag) {
+        for (ModuleNeeded module : modulesNeeded) {
+            for (ModuleNeeded current : list) {
+                if (current.getContext().equals(module.getContext()) && current.getModuleName().equals(module.getModuleName())) {
+                    if (module.getStatus() == ELibraryInstallStatus.NOT_INSTALLED && (current.getRequiredIf() != null && !current.getRequiredIf().equals("String_Node_Str"))) {
+                        Problem problem = new Problem(element, "String_Node_Str" + current.getModuleName() + "String_Node_Str", ProblemStatus.ERROR);
+                        problem.setKey("String_Node_Str" + current.getModuleName());
+                        toReturn.add(problem);
+                    }
+                }
+            }
+        }
+    } else {
+        for (ModuleNeeded module : modulesNeeded) {
+            for (ModuleNeeded current : list) {
+                if (current.getContext().equals(module.getContext()) && current.getModuleName().equals(module.getModuleName())) {
+                    if (module.getStatus() == ELibraryInstallStatus.NOT_INSTALLED && current.isRequired()) {
+                        Problem problem = new Problem(element, "String_Node_Str" + current.getModuleName() + "String_Node_Str", ProblemStatus.ERROR);
+                        problem.setKey("String_Node_Str" + current.getModuleName());
+                        toReturn.add(problem);
+                    }
                 }


Input:
private void select(ShortPoint2D pos) {
    if (grid.isInBounds(pos)) {
        short x = pos.x;
        short y = pos.y;
        IGuiMovable m1 = grid.getMovable((short) (x + 1), (short) (y + 1));
        IGuiMovable m2 = grid.getMovable((x), (short) (y + 1));
        IGuiMovable m3 = grid.getMovable(x, y);
        IGuiMovable m4 = grid.getMovable((short) (x + 1), (short) (y + 2));
        if (m1 != null) {
            setSelection(new SelectionSet(m1));
        } else if (m2 != null) {
            setSelection(new SelectionSet(m2));
        } else if (m3 != null) {
            setSelection(new SelectionSet(m3));
        } else if (m4 != null) {
            setSelection(new SelectionSet(m4));
        } else {
            IBuilding building = getBuildingAround(pos);
            if (building != null) {
                setSelection(new SelectionSet(building));
            } else {
                setSelection(new SelectionSet());
            }
        }
    }
}

Output:
         short y = pos.y;
-        IGuiMovable m1 = grid.getMovable((short) (x + 1), (short) (y + 1));
+        IGuiMovable m1 = grid.getMovable(x, y);
+        IGuiMovable m3 = grid.getMovable((short) (x + 1), (short) (y + 1));
         IGuiMovable m2 = grid.getMovable((x), (short) (y + 1));


Input:
public List<Package> fillSchemas(Connection dbConn, DatabaseMetaData dbJDBCMetadata, IMetadataConnection metaConnection, List<String> schemaFilter) {
    List<Schema> returnSchemas = new ArrayList<Schema>();
    if (dbJDBCMetadata == null || (dbConn != null && ConnectionHelper.getCatalogs(dbConn).size() > 0)) {
        return null;
    }
    ResultSet schemas = null;
    if (dbConn != null && EDatabaseTypeName.TERADATA.getProduct().equals(((DatabaseConnection) dbConn).getProductId())) {
        if (!dbConn.isContextMode()) {
            String sid = ((DatabaseConnection) dbConn).getSID();
            if (sid != null && sid.length() > 0) {
                schemaFilter.add(sid);
            }
        } else {
            IMetadataConnection iMetadataCon = metaConnection;
            if (iMetadataCon == null) {
                iMetadataCon = ConvertionHelper.convert(dbConn);
            }
            String sid = iMetadataCon.getDatabase();
            if (sid != null && sid.length() > 0) {
                schemaFilter.add(sid);
            }
        }
    }
    if (dbConn != null && dbConn.isContextMode()) {
        if (EDatabaseTypeName.ORACLEFORSID.getProduct().equals(((DatabaseConnection) dbConn).getProductId()) || EDatabaseTypeName.IBMDB2.getProduct().equals(((DatabaseConnection) dbConn).getProductId())) {
            IMetadataConnection iMetadataCon = metaConnection;
            if (iMetadataCon == null) {
                iMetadataCon = ConvertionHelper.convert(dbConn);
            }
            if (iMetadataCon != null) {
                String schemaTemp = iMetadataCon.getSchema();
                if ("String_Node_Str".equals(schemaTemp)) {
                    schemaFilter.clear();
                }
            }
        }
    }
    try {
        if (dbConn != null && EDatabaseTypeName.ACCESS.getProduct().equals(((DatabaseConnection) dbConn).getProductId())) {
            return null;
        }
        schemas = dbJDBCMetadata.getSchemas();
    } catch (SQLException e) {
        log.warn("String_Node_Str");
    }
    boolean hasSchema = false;
    try {
        if (schemas != null) {
            String schemaName = null;
            while (schemas.next()) {
                if (!ConnectionUtils.isOdbcTeradata(dbJDBCMetadata)) {
                    schemaName = schemas.getString(MetaDataConstants.TABLE_SCHEM.name());
                    if (schemaName == null) {
                        schemaName = schemas.getString(DatabaseConstant.ODBC_ORACLE_SCHEMA_NAME);
                    }
                    if (schemaName == null) {
                        schemaName = schemas.getString(1);
                    }
                } else {
                    schemaName = schemas.getString(1);
                }
                hasSchema = true;
                if (!isNullUiSchema(dbConn) && dbConn != null) {
                    String uiSchemaOnConnWizard = ((DatabaseConnection) dbConn).getUiSchema();
                    CWMService cwmService = new TalendCWMService();
                    Schema schema = SchemaHelper.createSchema(cwmService.getReadableName(dbConn, uiSchemaOnConnWizard));
                    returnSchemas.add(schema);
                    break;
                } else if (isCreateElement(schemaFilter, schemaName)) {
                    Schema schema = SchemaHelper.createSchema(schemaName);
                    returnSchemas.add(schema);
                }
            }
            schemas.close();
        }
    } catch (SQLException e) {
        log.error(e, e);
    }
    if (!hasSchema) {
        Schema schema = SchemaHelper.createSchema("String_Node_Str");
        returnSchemas.add(schema);
    }
    Set<MetadataTable> tableSet = new HashSet<MetadataTable>();
    if (dbConn != null) {
        tableSet.addAll(ConnectionHelper.getTables(dbConn));
    }
    List<Schema> oldSchemas = new ArrayList<Schema>();
    for (MetadataTable table : tableSet) {
        EObject eContainer = table.eContainer();
        if (eContainer != null && eContainer instanceof Schema && !oldSchemas.contains(eContainer)) {
            oldSchemas.add((Schema) eContainer);
        }
    }
    if (isLinked() && !returnSchemas.isEmpty()) {
        ConnectionHelper.addSchemas(returnSchemas, dbConn);
    }
    for (Schema schema : oldSchemas) {
        List<Schema> list = new ArrayList<Schema>();
        String name = schema.getName();
        Schema s = (Schema) ConnectionHelper.getPackage(name, dbConn, Schema.class);
        if (s != null) {
            list.add(s);
            ConnectionHelper.removeSchemas(list, dbConn);
            ConnectionHelper.addSchema(schema, dbConn);
        } else {
            ConnectionHelper.addSchema(schema, dbConn);
        }
    }
    return ListUtils.castList(Package.class, returnSchemas);
}

Output:
     List<Schema> returnSchemas = new ArrayList<Schema>();
-    if (dbJDBCMetadata == null || (dbConn != null && ConnectionHelper.getCatalogs(dbConn).size() > 0)) {
+    if (dbJDBCMetadata == null || (dbConn != null && ConnectionHelper.getCatalogs(dbConn).size() > 0) || ConnectionUtils.isSybase(dbJDBCMetadata)) {
         return null;


Input:
public boolean connectTo(ForgeDirection dir) {
    TileEntity te = worldObj.getTileEntity(xCoord + dir.offsetX, yCoord + dir.offsetY, zCoord + dir.offsetZ);
    if (te instanceof TileEntityPresent) {
        return connectTo((TileEntityPresent) te, dir);
    }
    return false;
}

Output:
 public boolean connectTo(ForgeDirection dir) {
-    TileEntity te = worldObj.getTileEntity(xCoord + dir.offsetX, yCoord + dir.offsetY, zCoord + dir.offsetZ);
+    int x = xCoord + dir.offsetX, y = yCoord + dir.offsetY, z = zCoord + dir.offsetZ;
+    TileEntity te = getTileSafe(x, y, z);
     if (te instanceof TileEntityPresent) {


Input:
protected void writeExtraNamespaces(List extraNamespaces, XMLRecord xmlRecord, AbstractSession session) {
    if (extraNamespaces == null) {
        return;
    }
    for (int i = 0, extraNamespacesSize = extraNamespaces.size(); i < extraNamespacesSize; i++) {
        Namespace next = (Namespace) extraNamespaces.get(i);
        String prefix = next.getPrefix();
        if (((MarshalRecord) xmlRecord).hasCustomNamespaceMapper()) {
            prefix = ((MarshalRecord) xmlRecord).getNamespaceResolver().resolveNamespaceURI(next.getNamespaceURI());
        }
        ((MarshalRecord) xmlRecord).attribute(XMLConstants.XMLNS_URL, prefix, XMLConstants.XMLNS + XMLConstants.COLON + prefix, next.getNamespaceURI());
    }
}

Output:
         }
-        ((MarshalRecord) xmlRecord).attribute(XMLConstants.XMLNS_URL, prefix, XMLConstants.XMLNS + XMLConstants.COLON + prefix, next.getNamespaceURI());
+        ((MarshalRecord) xmlRecord).namespaceDeclaration(prefix, next.getNamespaceURI());
     }


Input:
public void schedulJob(final ExecutionGraph executionGraph) throws SchedulingException {
    final Map<InstanceType, InstanceTypeDescription> availableInstances = getInstanceManager().getMapOfAvailableInstanceTypes();
    for (int i = 0; i < executionGraph.getNumberOfStages(); i++) {
        final Map<InstanceType, Integer> requiredInstanceTypes = new HashMap<InstanceType, Integer>();
        final ExecutionStage stage = executionGraph.getStage(i);
        stage.collectRequiredInstanceTypes(requiredInstanceTypes, ExecutionState.CREATED);
        final Iterator<Map.Entry<InstanceType, Integer>> it = requiredInstanceTypes.entrySet().iterator();
        while (it.hasNext()) {
            final Map.Entry<InstanceType, Integer> entry = it.next();
            final InstanceTypeDescription descr = availableInstances.get(entry.getKey());
            if (descr == null) {
                throw new SchedulingException("String_Node_Str" + entry.getKey() + "String_Node_Str");
            }
            if (descr.getMaximumNumberOfAvailableInstances() != -1 && descr.getMaximumNumberOfAvailableInstances() < entry.getValue().intValue()) {
                throw new SchedulingException("String_Node_Str" + entry.getValue().intValue() + "String_Node_Str" + entry.getKey() + "String_Node_Str" + descr.getMaximumNumberOfAvailableInstances() + "String_Node_Str");
            }
        }
    }
    executionGraph.registerJobStatusListener(this);
    final ExecutionGraphIterator it2 = new ExecutionGraphIterator(executionGraph, true);
    while (it2.hasNext()) {
        final ExecutionVertex vertex = it2.next();
        if (vertex.getExecutionState() != ExecutionState.CREATED) {
            LOG.error("String_Node_Str" + vertex + "String_Node_Str" + vertex.getExecutionState() + "String_Node_Str" + ExecutionState.CREATED);
        }
        vertex.getEnvironment().registerExecutionListener(new QueueExecutionListener(this, vertex));
        vertex.setExecutionState(ExecutionState.SCHEDULED);
    }
    executionGraph.registerExecutionStageListener(this);
    final ExecutionStage executionStage = executionGraph.getCurrentExecutionStage();
    try {
        requestInstances(executionStage);
    } catch (InstanceException e) {
        throw new SchedulingException(StringUtils.stringifyException(e));
    }
    synchronized (this.jobQueue) {
        this.jobQueue.add(executionGraph);
    }
}

Output:
     } catch (InstanceException e) {
-        throw new SchedulingException(StringUtils.stringifyException(e));
-    }
-    synchronized (this.jobQueue) {
-        this.jobQueue.add(executionGraph);
+        LOG.error(StringUtils.stringifyException(e));
     }


Input:
private void initCurrentAndCapacity(CostFunctionCapability powerCost) {
    Battery battery = new Battery(getModel());
    double initialStateOfCharge = battery.getInitialStateOfCharge();
    double stateOfCharge = initialStateOfCharge;
    double voltage, current, power;
    Collection<Long> changeTimes = getChangeTimes(CostType.POWER);
    for (Long t : changeTimes) {
        capacityMap.put(t, stateOfCharge);
        power = powerCost.getValue(t);
        if ((battery.getStateOfCharge() < 100.0) || ((battery.getStateOfCharge() == initialStateOfCharge) && (power > 0.0))) {
            voltage = battery.getVoltage();
            current = power / voltage;
            stateOfCharge = battery.setStateOfCharge(power, (double) TIME_INTERVAL);
        } else {
            stateOfCharge = initialStateOfCharge;
            current = 0.0;
        }
        currentMap.put(t, current);
    }
}

Output:
     double stateOfCharge = initialStateOfCharge;
-    double voltage, current, power;
+    double voltage, current = 0.0, power;
     Collection<Long> changeTimes = getChangeTimes(CostType.POWER);


Input:
private boolean marshalSingleValueWithNodeValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object value, CoreAbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext, NodeValue unwrappedNodeValue) {
    Object fieldValue = value;
    if (value instanceof Root && !unwrappedNodeValue.isAnyMappingNodeValue()) {
        fieldValue = ((Root) value).getObject();
    }
    if (unwrappedNodeValue != null) {
        unwrappedNodeValue.marshalSingleValue(xPathFragment, marshalRecord, object, fieldValue, session, namespaceResolver, marshalContext);
    }
    return true;
}

Output:
     if (unwrappedNodeValue != null) {
-        unwrappedNodeValue.marshalSingleValue(xPathFragment, marshalRecord, object, fieldValue, session, namespaceResolver, marshalContext);
+        unwrappedNodeValue.marshalSingleValue(xPathFragment, marshalRecord, object, value, session, namespaceResolver, marshalContext);
     }