Input:
public void run(CommandLine cmd) throws ParseException, IOException {
    DepTreebank depTreebank;
    if (cmd.hasOption("String_Node_Str")) {
        log.info("String_Node_Str");
        String trainPath = cmd.getOptionValue("String_Node_Str");
        int maxSentenceLength = Command.getOptionValue(cmd, "String_Node_Str", Integer.MAX_VALUE);
        int maxNumSentences = Command.getOptionValue(cmd, "String_Node_Str", Integer.MAX_VALUE);
        depTreebank = new DepTreebank(maxSentenceLength, maxNumSentences);
        if (cmd.hasOption("String_Node_Str")) {
            depTreebank.setTreeFilter(new VerbTreeFilter());
        }
        depTreebank.loadPath(trainPath);
        String reduceTags = Command.getOptionValue(cmd, "String_Node_Str", "String_Node_Str");
        if ("String_Node_Str".equals(reduceTags)) {
            log.info("String_Node_Str");
            (new Ptb45To17TagReducer()).reduceTags(depTreebank);
        } else if (!"String_Node_Str".equals(reduceTags)) {
            log.info("String_Node_Str" + reduceTags);
            (new FileMapTagReducer(new File(reduceTags))).reduceTags(depTreebank);
        }
    } else if (cmd.hasOption("String_Node_Str")) {
        DmvModel trueModel = SimpleStaticDmvModel.getTwoPosTagInstance();
        long syntheticSeed = 123454321;
        if (cmd.hasOption("String_Node_Str")) {
            syntheticSeed = Long.parseLong(cmd.getOptionValue("String_Node_Str"));
        }
        DmvDepTreeGenerator generator = new DmvDepTreeGenerator(trueModel, syntheticSeed);
        int maxNumSentences = Command.getOptionValue(cmd, "String_Node_Str", 100);
        depTreebank = generator.getTreebank(maxNumSentences);
    } else {
        throw new ParseException("String_Node_Str");
    }
    log.info("String_Node_Str" + depTreebank.size());
    log.info("String_Node_Str" + depTreebank.getNumTokens());
    log.info("String_Node_Str" + depTreebank.getNumTypes());
    SentenceCollection sentences = depTreebank.getSentences();
    printSentences(cmd, depTreebank, sentences);
    if (cmd.hasOption("String_Node_Str")) {
        DmvRelaxation dw = (DmvRelaxation) TrainerFactory.getTrainer(cmd);
        dw.init(sentences, DmvDantzigWolfeRelaxationTest.getInitFeasSol(sentences, 2));
        DmvSolution initBoundsSol = updateBounds(cmd, sentences, dw);
        Stopwatch timer = new Stopwatch();
        timer.start();
        RelaxedDmvSolution relaxSol = dw.solveRelaxation();
        timer.stop();
        log.info("String_Node_Str" + Time.totMs(timer));
        log.info("String_Node_Str" + relaxSol.getScore());
        if (initBoundsSol != null) {
            log.info("String_Node_Str" + Math.abs(relaxSol.getScore() - initBoundsSol.getScore()) / Math.abs(initBoundsSol.getScore()));
        }
    } else {
        log.info("String_Node_Str");
        Trainer trainer = (Trainer) TrainerFactory.getTrainer(cmd);
        if (trainer instanceof BnBDmvTrainer) {
            BnBDmvTrainer bnb = (BnBDmvTrainer) trainer;
            bnb.init(sentences);
            updateBounds(cmd, sentences, bnb.getRootRelaxation());
            bnb.train();
        } else {
            trainer.train(sentences);
        }
        Model model = trainer.getModel();
        log.info("String_Node_Str");
        ViterbiParser parser = TrainerFactory.getEvalParser();
        Evaluator pwEval = new DependencyParserEvaluator(parser, depTreebank);
        pwEval.evaluate(model);
        pwEval.print();
        String printModel = Command.getOptionValue(cmd, "String_Node_Str", null);
        if (printModel != null) {
            BufferedWriter writer = new BufferedWriter(new FileWriter(printModel));
            writer.write("String_Node_Str");
            writer.write(model.toString());
            writer.close();
        }
    }
}

Output:
         DmvRelaxation dw = (DmvRelaxation) TrainerFactory.getTrainer(cmd);
-        dw.init(sentences, DmvDantzigWolfeRelaxationTest.getInitFeasSol(sentences, 2));
+        dw.setSentences(sentences);
+        dw.init(DmvDantzigWolfeRelaxationTest.getInitFeasSol(sentences, 2));
         DmvSolution initBoundsSol = updateBounds(cmd, sentences, dw);


Input:
public boolean hasFacet() {
    try {
        IFacetedProject facetedProject = ProjectFacetsManager.create(project);
        return facetedProject.hasProjectFacet(FACET);
    } catch (CoreException e) {
        CloudFoundryPlugin.logError(e);
        return false;
    }
}

Output:
         IFacetedProject facetedProject = ProjectFacetsManager.create(project);
-        return facetedProject.hasProjectFacet(FACET);
+        return facetedProject != null && facetedProject.hasProjectFacet(FACET);
     } catch (CoreException e) {


Input:
public void endElement(XPathFragment xPathFragment, UnmarshalRecord unmarshalRecord) {
    SAXFragmentBuilder builder = unmarshalRecord.getFragmentBuilder();
    Object value = builder.getNodes().pop();
    unmarshalRecord.addAttributeValue(this, value);
}

Output:
     SAXFragmentBuilder builder = unmarshalRecord.getFragmentBuilder();
-    Object value = builder.getNodes().pop();
+    Object value = builder.getNodes().remove(builder.getNodes().size() - 1);
     unmarshalRecord.addAttributeValue(this, value);


Input:
static BigDecimal getDecimalArg(Evaluator evaluator, Exp[] args, int index) {
    Object o = args[index].evaluateScalar(evaluator);
    if (o instanceof BigDecimal) {
        return (BigDecimal) o;
    } else if (o instanceof BigInteger) {
        return new BigDecimal((BigInteger) o);
    } else if (o instanceof Number) {
        return new BigDecimal(((Number) o).doubleValue());
    } else {
        throw Util.newInternal("String_Node_Str" + o + "String_Node_Str");
    }
}

Output:
 static BigDecimal getDecimalArg(Evaluator evaluator, Exp[] args, int index) {
-    Object o = args[index].evaluateScalar(evaluator);
+    Object o = getScalarArg(evaluator, args, index);
     if (o instanceof BigDecimal) {


Input:
private boolean applyCascadingDelete(Query baseQuery, AbstractCommonQueryBuilder<?, ?, ?, ?, ?> queryBuilder, List<Query> participatingQueries, StringBuilder sb, String cteBaseName, boolean firstCte) {
    if (queryBuilder.statementType == DbmsStatementType.DELETE) {
        List<String> cascadingDeleteSqls = cbf.getExtendedQuerySupport().getCascadingDeleteSql(em, baseQuery);
        StringBuilder cascadingDeleteSqlSb = new StringBuilder();
        int cteBaseNameCount = 0;
        for (String cascadingDeleteSql : cascadingDeleteSqls) {
            if (firstCte) {
                firstCte = false;
            } else {
                sb.append("String_Node_Str");
            }
            participatingQueries.add(baseQuery);
            sb.append(cteBaseName);
            sb.append('_').append(cteBaseNameCount);
            sb.append("String_Node_Str");
            cascadingDeleteSqlSb.setLength(0);
            cascadingDeleteSqlSb.append(cascadingDeleteSql);
            dbmsDialect.appendExtendedSql(cascadingDeleteSqlSb, DbmsStatementType.DELETE, false, true, null, null, null, null, null);
            sb.append(cascadingDeleteSqlSb);
            sb.append("String_Node_Str");
        }
    }
    return firstCte;
}

Output:
             sb.append(cteBaseName);
-            sb.append('_').append(cteBaseNameCount);
+            sb.append('_').append(cteBaseNameCount++);
             sb.append("String_Node_Str");


Input:
public void scanForIBeacons(Context context, int scanDurationTime, int scanGapTime) {
    Logger.d(TAG, "String_Node_Str");
    Logger.d(TAG, "String_Node_Str" + scanDurationTime);
    Logger.d(TAG, "String_Node_Str" + scanGapTime);
    this.cancelServiceAlarm(context);
    Singleton.getInstance().setNumberOfScans(0);
    Intent serviceIntent = new Intent(context, ScanService.class);
    serviceIntent.putExtra(CustomConstants.Payloads.PAYLOAD_1.getString(), scanDurationTime);
    serviceIntent.putExtra(CustomConstants.Payloads.PAYLOAD_2.getString(), scanGapTime);
    Logger.d(TAG, "String_Node_Str");
    context.startService(serviceIntent);
}

Output:
 public void scanForIBeacons(Context context, int scanDurationTime, int scanGapTime) {
-    Logger.d(TAG, "String_Node_Str");
-    Logger.d(TAG, "String_Node_Str" + scanDurationTime);
-    Logger.d(TAG, "String_Node_Str" + scanGapTime);
-    this.cancelServiceAlarm(context);
-    Singleton.getInstance().setNumberOfScans(0);
-    Intent serviceIntent = new Intent(context, ScanService.class);
-    serviceIntent.putExtra(CustomConstants.Payloads.PAYLOAD_1.getString(), scanDurationTime);
-    serviceIntent.putExtra(CustomConstants.Payloads.PAYLOAD_2.getString(), scanGapTime);
-    Logger.d(TAG, "String_Node_Str");
-    context.startService(serviceIntent);
+    if (!isAlarmUp(context)) {
+        Logger.d(TAG, "String_Node_Str");
+        Logger.d(TAG, "String_Node_Str" + scanDurationTime);
+        Logger.d(TAG, "String_Node_Str" + scanGapTime);
+        this.cancelService(context);
+        Singleton.getInstance().setNumberOfScans(0);
+        Intent serviceIntent = new Intent(context, ScanService.class);
+        serviceIntent.putExtra(CustomConstants.Payloads.PAYLOAD_1.getString(), scanDurationTime);
+        serviceIntent.putExtra(CustomConstants.Payloads.PAYLOAD_2.getString(), scanGapTime);
+        Logger.d(TAG, "String_Node_Str");
+        context.startService(serviceIntent);
+    } else {
+        Logger.e(TAG, "String_Node_Str");
+    }
 }


Input:
public Driver getWrappedObject() throws SQLException {
    if (_embedded != null) {
        return _embedded;
    } else if (_netclient != null) {
        return _netclient;
    } else {
        throw nothingWrapped();
    }
}

Output:
     } else {
-        throw nothingWrapped();
+        throw nothingWrapped(null);
     }


Input:
public boolean finish() {
    if (treeViewer != null) {
        treeViewer.removeCheckStateListener(checkStateListener);
    }
    List<ContextParameterType> contextEditableResultValuesList = null;
    if (manager != null) {
        contextEditableResultValuesList = manager.getContextEditableResultValuesList();
    }
    manager = createJobScriptsManager();
    if (nodes.length == 1) {
        RepositoryNode node = nodes[0];
        if (node.getType() == ENodeType.SYSTEM_FOLDER) {
            manager.setTopFolderName(JOBDESIGNER);
        } else {
            manager.setTopFolderName(getDefaultFileNameWithType());
        }
    } else {
        manager.setTopFolderName(getDefaultFileNameWithType());
    }
    saveWidgetValues();
    if (!ensureTargetIsValid()) {
        return false;
    }
    if (ensureLog4jSettingIsValid()) {
        MessageDialog dialog = new MessageDialog(getShell(), "String_Node_Str", null, Messages.getString("String_Node_Str"), MessageDialog.QUESTION, new String[] { IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL }, 0);
        dialog.open();
        int result = dialog.getReturnCode();
        if (result != MessageDialog.OK) {
            return false;
        }
    }
    if (contextEditableResultValuesList == null) {
        manager.setContextEditableResultValuesList(new ArrayList<ContextParameterType>());
    } else {
        manager.setContextEditableResultValuesList(contextEditableResultValuesList);
    }
    if (manager instanceof PetalsJobJavaScriptsManager) {
        PetalsTemporaryOptionsKeeper.INSTANCE.setSelection(selection);
    }
    manager.setMultiNodes(isMultiNodes());
    IRunnableWithProgress worker = new JobExportAction(Arrays.asList(getCheckNodes()), getSelectedJobVersion(), manager, originalRootFolderName, getProcessType());
    try {
        getContainer().run(false, true, worker);
    } catch (InvocationTargetException e) {
        MessageBoxExceptionHandler.process(e.getCause(), getShell());
        return false;
    } catch (InterruptedException e) {
        return false;
    }
    if (zipOption != null && zipOption.equals("String_Node_Str")) {
        try {
            String zipFile = manager.getDestinationPath();
            File file = new File(zipFile);
            if (file.exists()) {
                ZipToFile.unZipFile(zipFile, file.getParentFile().getAbsolutePath());
            }
        } catch (Exception e) {
            MessageBoxExceptionHandler.process(e, getShell());
            return false;
        }
    }
    if (treeViewer != null) {
        treeViewer.dispose();
    }
    return true;
}

Output:
         if (node.getType() == ENodeType.SYSTEM_FOLDER) {
-            manager.setTopFolderName(JOBDESIGNER);
+            manager.setTopFolderName(ProjectManager.getInstance().getCurrentProject().getLabel());
         } else {


Input:
public static File chooseFile(boolean useJFileChooser, final Component parent, final String selectedFile, final FileFilter fileFilter, final String dialogTitle, final DialogType dialogType, final SelectionMode selectionMode) {
    final boolean isSaveDialog = (dialogType == DialogType.SAVE);
    final boolean isDirectoriesOnly = (selectionMode == SelectionMode.DIRECTORIES_ONLY);
    if (isSaveDialog && isDirectoriesOnly)
        useJFileChooser = true;
    String title = dialogTitle;
    if (title == null)
        title = (isSaveDialog ? "String_Node_Str" : "String_Node_Str") + (fileFilter == null ? "String_Node_Str" : "String_Node_Str" + fileFilter.getDescription());
    File file = null;
    if (useJFileChooser) {
        final JFileChooser fileChooser = new JFileChooser();
        fileChooser.setDialogTitle(title);
        if (selectedFile != null)
            fileChooser.setSelectedFile(new File(selectedFile));
        fileChooser.setFileSelectionMode(isDirectoriesOnly ? JFileChooser.DIRECTORIES_ONLY : JFileChooser.FILES_ONLY);
        fileChooser.setFileFilter(fileFilter);
        final int returnVal = isSaveDialog ? fileChooser.showSaveDialog(parent) : fileChooser.showOpenDialog(parent);
        if (returnVal == JFileChooser.APPROVE_OPTION)
            file = fileChooser.getSelectedFile();
    } else {
        final int fdMode = isSaveDialog ? FileDialog.SAVE : FileDialog.LOAD;
        final FileDialog fd;
        if (parent != null || parent instanceof Frame)
            fd = new FileDialog((Frame) parent, title, fdMode);
        else if (parent != null || parent instanceof Dialog)
            fd = new FileDialog((Dialog) parent, title, fdMode);
        else
            fd = new FileDialog((Frame) null, title, fdMode);
        if (selectedFile != null) {
            fd.setDirectory(new File(selectedFile).getParent());
            fd.setFile(new File(selectedFile).getName());
        }
        System.setProperty("String_Node_Str", isDirectoriesOnly ? "String_Node_Str" : "String_Node_Str");
        final AtomicBoolean workedWithFilenameFilter = new AtomicBoolean(false);
        if (fileFilter != null) {
            final FilenameFilter filenameFilter = new FilenameFilter() {
                private boolean firstTime = true;
                public boolean accept(final File dir, final String name) {
                    if (firstTime) {
                        workedWithFilenameFilter.set(true);
                        firstTime = false;
                    }
                    return fileFilter.accept(new File(dir, name));
                }
            };
            fd.setFilenameFilter(filenameFilter);
            fd.setVisible(true);
        }
        if (fileFilter == null || (isMac() && !workedWithFilenameFilter.get())) {
            fd.setFilenameFilter(null);
            fd.setVisible(true);
        }
        final String filename = fd.getFile();
        if (filename != null) {
            file = new File(fd.getDirectory() + filename);
        }
    }
    return file;
}

Output:
         final FileDialog fd;
-        if (parent != null || parent instanceof Frame)
+        if (parent != null && parent instanceof Frame)
             fd = new FileDialog((Frame) parent, title, fdMode);


Input:
public void upstreamFinished() {
    if (remainingUpstreams.decrementAndGet() <= 0) {
        rows = grouper.finish();
    }
}

Output:
     if (remainingUpstreams.decrementAndGet() <= 0) {
-        rows = grouper.finish();
+        grouper.finish();
     }


Input:
public boolean isSlotEnabled(int idx) {
    if (idx == 1)
        return Platform.isServer() ? ct.craftingMode == false : craftingMode == false;
    if (idx == 2)
        return Platform.isServer() ? ct.craftingMode == true : craftingMode == true;
    return false;
}

Output:
     if (idx == 1)
-        return Platform.isServer() ? ct.craftingMode == false : craftingMode == false;
+        return Platform.isServer() ? ct.isCraftingRecipe() == false : craftingMode == false;
     if (idx == 2)


Input:
public void onRawMessage(RawMessageEvent event) {
    if (event.message.command.equals("String_Node_Str")) {
        event.setHandled();
        String[] sender = event.message.prefix.split("String_Node_Str");
        IRCUser user = event.network.getUser(sender[0]);
        BotAPI.console.sendMessageToConsole("String_Node_Str", user.getUsername(), event.message.params[0]);
        user.setUsername(event.message.params[0]);
        BotAPI.eventBus.postEvent(new UserNicknameChangedEvent(user, sender[0]));
    } else if (event.message.command.equals("String_Node_Str")) {
        event.setHandled();
        String[] sender = event.message.prefix.split("String_Node_Str");
        IRCUser user = event.network.getUser(sender[0]);
        BotAPI.console.sendMessageToConsole("String_Node_Str", event.message.params[0], user.getUsername(), event.message.trailing);
        String prefix = BotAPI.configuration.getCommandPrefix();
        if (event.message.params[0].startsWith(prefix)) {
            UserCommandEvent commandEvent = new UserCommandEvent(user, event.message.params[0], event.message.trailing.substring(prefix.length()));
            if (BotAPI.eventBus.postEvent(commandEvent)) {
                BotAPI.serverConnection.addToSendQueue("String_Node_Str", event.message.params[0], user.getUsername());
            }
        } else {
            BotAPI.eventBus.postEvent(new UserMessageEvent(user, event.message.params[0], event.message.trailing));
        }
    }
}

Output:
         IRCUser user = event.network.getUser(sender[0]);
-        BotAPI.console.sendMessageToConsole("String_Node_Str", user.getUsername(), event.message.params[0]);
-        user.setUsername(event.message.params[0]);
+        BotAPI.console.sendMessageToConsole("String_Node_Str", user.getUsername(), event.message.trailing);
+        user.setUsername(event.message.trailing);
         BotAPI.eventBus.postEvent(new UserNicknameChangedEvent(user, sender[0]));


Input:
public EmmaBuildAction getLastResult() {
    for (Build b = project.getLastBuild(); b != null; b = b.getPreviousBuild()) {
        if (b.getResult() == Result.FAILURE)
            continue;
        EmmaBuildAction r = b.getAction(EmmaBuildAction.class);
        if (r != null)
            return r;
    }
    return null;
}

Output:
 public EmmaBuildAction getLastResult() {
-    for (Build b = project.getLastBuild(); b != null; b = b.getPreviousBuild()) {
+    for (Build<?, ?> b = project.getLastBuild(); b != null; b = b.getPreviousBuild()) {
         if (b.getResult() == Result.FAILURE)


Input:
public VisitStatus acceptASTNode(ASTNode node, TypeLookupResult result, IJavaElement enclosingElement) {
    if (node instanceof ClassNode) {
        ClassNode orig = (ClassNode) node;
        ClassNode redirect = orig.redirect();
        if (orig == redirect) {
            if (orig.getNameWithoutPackage().equalsIgnoreCase(simpleName)) {
                boolean matchFound;
                switch(typeSuffix) {
                    case CLASS_SUFFIX:
                        matchFound = isClass(orig);
                        break;
                    case CLASS_AND_INTERFACE_SUFFIX:
                        matchFound = orig.isInterface() || isClass(orig);
                        break;
                    case CLASS_AND_ENUM_SUFFIX:
                        matchFound = orig.isInterface() || orig.isEnum();
                        break;
                    case INTERFACE_SUFFIX:
                        matchFound = orig.isInterface();
                        break;
                    case INTERFACE_AND_ANNOTATION_SUFFIX:
                        matchFound = orig.isInterface() || orig.isAnnotationDefinition();
                        break;
                    case ENUM_SUFFIX:
                        matchFound = orig.isEnum();
                        break;
                    case ANNOTATION_TYPE_SUFFIX:
                        matchFound = orig.isAnnotationDefinition();
                        break;
                    default:
                        matchFound = true;
                        break;
                }
                if (matchFound) {
                    try {
                        requestor.acceptSearchMatch(new SearchMatch(enclosingElement, SearchMatch.A_ACCURATE, orig.getNameStart(), orig.getNameEnd() - orig.getNameStart(), participant, enclosingElement.getResource()));
                    } catch (CoreException e) {
                        Util.log(e, "String_Node_Str");
                    }
                }
            }
        }
    }
    return VisitStatus.CONTINUE;
}

Output:
                     try {
-                        requestor.acceptSearchMatch(new SearchMatch(enclosingElement, SearchMatch.A_ACCURATE, orig.getNameStart(), orig.getNameEnd() - orig.getNameStart(), participant, enclosingElement.getResource()));
+                        requestor.acceptSearchMatch(new SearchMatch(enclosingElement, SearchMatch.A_ACCURATE, orig.getNameStart(), orig.getNameEnd() - orig.getNameStart() + 1, participant, enclosingElement.getResource()));
                     } catch (CoreException e) {


Input:
public StartPAOSResponse sendStartPAOS(StartPAOS message) throws DispatcherException, PAOSException {
    Object msg = message;
    try {
        boolean firstLoop = true;
        while (true) {
            if (!firstLoop && tlsHandler.isSameChannel()) {
                throw new PAOSException("String_Node_Str");
            }
            firstLoop = false;
            StreamHttpClientConnection conn = openHttpStream();
            HttpContext ctx = new BasicHttpContext();
            HttpRequestExecutor httpexecutor = new HttpRequestExecutor();
            DefaultConnectionReuseStrategy reuse = new DefaultConnectionReuseStrategy();
            boolean isReusable;
            do {
                String resource = tlsHandler.getResource();
                BasicHttpEntityEnclosingRequest req = new BasicHttpEntityEnclosingRequest("String_Node_Str", resource);
                req.setParams(conn.getParams());
                HttpRequestHelper.setDefaultHeader(req, tlsHandler.getServerAddress());
                req.setHeader(HEADER_KEY_PAOS, HEADER_VALUE_PAOS);
                req.setHeader("String_Node_Str", "String_Node_Str");
                ContentType reqContentType = ContentType.create("String_Node_Str", "String_Node_Str");
                HttpUtils.dumpHttpRequest(logger, "String_Node_Str", req);
                String reqMsgStr = createPAOSResponse(msg);
                StringEntity reqMsg = new StringEntity(reqMsgStr, reqContentType);
                req.setEntity(reqMsg);
                req.setHeader(reqMsg.getContentType());
                req.setHeader("String_Node_Str", Long.toString(reqMsg.getContentLength()));
                HttpResponse response = httpexecutor.execute(req, conn, ctx);
                int statusCode = response.getStatusLine().getStatusCode();
                conn.receiveResponseEntity(response);
                HttpEntity entity = response.getEntity();
                byte[] entityData = FileUtils.toByteArray(entity.getContent());
                HttpUtils.dumpHttpResponse(logger, response, entityData);
                checkHTTPStatusCode(msg, statusCode);
                Object requestObj = processPAOSRequest(new ByteArrayInputStream(entityData));
                if (requestObj instanceof StartPAOSResponse) {
                    StartPAOSResponse startPAOSResponse = (StartPAOSResponse) requestObj;
                    WSHelper.checkResult(startPAOSResponse);
                    return startPAOSResponse;
                }
                msg = dispatcher.deliver(requestObj);
                isReusable = reuse.keepAlive(response, ctx);
            } while (isReusable);
        }
    } catch (HttpException ex) {
        throw new PAOSException("String_Node_Str", ex);
    } catch (IOException ex) {
        throw new PAOSException(ex);
    } catch (SOAPException ex) {
        throw new PAOSException("String_Node_Str", ex);
    } catch (URISyntaxException ex) {
        throw new PAOSException("String_Node_Str", ex);
    } catch (MarshallingTypeException ex) {
        throw new DispatcherException("String_Node_Str", ex);
    } catch (InvocationTargetException ex) {
        throw new DispatcherException("String_Node_Str", ex);
    } catch (TransformerException ex) {
        throw new DispatcherException(ex);
    } catch (WSException ex) {
        throw new PAOSException(ex);
    }
}

Output:
                 HttpRequestHelper.setDefaultHeader(req, tlsHandler.getServerAddress());
-                req.setHeader(HEADER_KEY_PAOS, HEADER_VALUE_PAOS);
+                req.setHeader(HEADER_KEY_PAOS, headerValuePaos);
                 req.setHeader("String_Node_Str", "String_Node_Str");


Input:
public Object[] getChildren(Object parent) {
    if (parent == null) {
        System.out.println("String_Node_Str");
    }
    if (parent instanceof XSDSchema) {
        EList xsdElementDeclarations = xsdSchema.getElementDeclarations();
        List<XSDElementDeclaration> list = new ArrayList<XSDElementDeclaration>();
        if (filter != null && !filter.isAll()) {
            for (XSDElementDeclaration el : (XSDElementDeclaration[]) xsdElementDeclarations.toArray(new XSDElementDeclaration[xsdElementDeclarations.size()])) {
                if (isInclude(el.getAnnotation())) {
                    list.add(el);
                }
            }
            return filterOutDuplicatedElems(list);
        }
        return filterOutDuplicatedElems(xsdElementDeclarations);
    }
    if (parent instanceof XSDAttributeGroupDefinition) {
        XSDAttributeGroupDefinition attributeGroupDefinition = (XSDAttributeGroupDefinition) parent;
        if (attributeGroupDefinition.getContents().size() == 0)
            attributeGroupDefinition = attributeGroupDefinition.getResolvedAttributeGroupDefinition();
        return attributeGroupDefinition.getContents().toArray(new Object[attributeGroupDefinition.getContents().size()]);
    }
    if (parent instanceof XSDParticle) {
        XSDParticle xsdParticle = (XSDParticle) parent;
        return getXSDParticleChildren(xsdParticle);
    }
    if (parent instanceof XSDModelGroup) {
        XSDModelGroup modelGroup = ((XSDModelGroup) parent);
        EList list = modelGroup.getContents();
        List<XSDParticle> ls = new ArrayList<XSDParticle>();
        if (filter != null && !filter.isAll()) {
            for (XSDParticle el : (XSDParticle[]) list.toArray(new XSDParticle[list.size()])) {
                XSDTerm tm = el.getTerm();
                if (tm instanceof XSDElementDeclaration) {
                    XSDAnnotation annotation = ((XSDElementDeclaration) tm).getAnnotation();
                    if (isInclude(annotation)) {
                        ls.add(el);
                    }
                }
            }
            return ls.toArray(new XSDParticle[ls.size()]);
        }
        return list.toArray(new Object[list.size()]);
    }
    if (parent instanceof XSDSimpleTypeDefinition) {
        XSDSimpleTypeDefinition std = (XSDSimpleTypeDefinition) parent;
        if (std.getVariety().equals(XSDVariety.ATOMIC_LITERAL)) {
            ArrayList list = new ArrayList();
            if (std != null && std.getSchema() != null && std.getSchema().getSchemaForSchema() != null)
                if (!std.getSchema().getSchemaForSchema().getTypeDefinitions().contains(std))
                    list.add(std.getBaseTypeDefinition());
            list.addAll(std.getFacetContents());
            return list.toArray(new Object[list.size()]);
        }
        if (std.getVariety().equals(XSDVariety.LIST_LITERAL)) {
            return new XSDSimpleTypeDefinition[] { std.getBaseTypeDefinition() };
        }
        if (std.getVariety().equals(XSDVariety.UNION_LITERAL))
            return std.getMemberTypeDefinitions().toArray(new XSDSimpleTypeDefinition[std.getMemberTypeDefinitions().size()]);
    }
    if (parent instanceof XSDElementDeclaration) {
        if (((XSDElementDeclaration) parent).isAbstract())
            return new Object[0];
        ArrayList<Object> list = new ArrayList<Object>();
        XSDTypeDefinition typeDefinition = ((XSDElementDeclaration) parent).getTypeDefinition();
        if (typeDefinition instanceof XSDComplexTypeDefinition) {
            list.addAll(Util.getComplexTypeDefinitionChildren((XSDComplexTypeDefinition) typeDefinition));
        } else {
            list.add(((XSDElementDeclaration) parent).getTypeDefinition());
        }
        if (filter != null && !filter.isAll()) {
        } else {
            list.addAll(((XSDElementDeclaration) parent).getIdentityConstraintDefinitions());
        }
        XSDAnnotation annotation = ((XSDElementDeclaration) parent).getAnnotation();
        if (filter != null && !filter.isAll()) {
        } else {
            if (annotation != null) {
                list.add(annotation);
            }
        }
        return list.toArray(new Object[list.size()]);
    }
    if (parent instanceof XSDIdentityConstraintDefinition) {
        ArrayList list = new ArrayList();
        if (filter != null && !filter.isAll()) {
        } else {
            list.add(((XSDIdentityConstraintDefinition) parent).getSelector());
            list.addAll(((XSDIdentityConstraintDefinition) parent).getFields());
        }
        return list.toArray(new Object[list.size()]);
    }
    if (parent instanceof XSDAnnotation) {
        ArrayList list = new ArrayList();
        if (filter != null && !filter.isAll()) {
        } else {
            XSDAnnotation annotation = (XSDAnnotation) parent;
            list.addAll(annotation.getUserInformation());
            list.addAll(annotation.getApplicationInformation());
        }
        return list.size() == 0 ? new Object[0] : list.toArray(new Object[list.size()]);
    }
    if (parent instanceof Element) {
        return new Object[0];
    }
    return new Object[0];
}

Output:
     if (parent == null) {
-        System.out.println("String_Node_Str");
+        log.info("String_Node_Str");
     }


Input:
protected boolean runAnalysis(Analysis analysis, String sqlStatement) {
    boolean ok = true;
    TypedReturnCode<MdmWebserviceConnection> trc = this.getMdmConnection(analysis);
    if (!trc.isOk()) {
        return traceError(Messages.getString("String_Node_Str", analysis.getName(), trc.getMessage()));
    }
    MdmWebserviceConnection connection = trc.getObject();
    try {
        Map<ModelElement, List<Indicator>> elementToIndicator = new HashMap<ModelElement, List<Indicator>>();
        Collection<Indicator> indicators = IndicatorHelper.getIndicatorLeaves(analysis.getResults());
        ok = runAnalysisIndicators(connection, elementToIndicator, indicators);
        setRowCountAndNullCount(elementToIndicator);
    } catch (RemoteException e) {
        log.error(e.getMessage(), e);
        this.errorMessage = e.getMessage();
        String unableDirectQueryStr = "String_Node_Str";
        if (getErrorMessage().contains(unableDirectQueryStr)) {
            String sqlModeUnsupportedStr = Messages.getString("String_Node_Str");
            String refactoredErrorMessage = StringUtils.replace(getErrorMessage(), unableDirectQueryStr, sqlModeUnsupportedStr, -1);
            setError(refactoredErrorMessage);
        }
        ok = false;
    } catch (ServiceException e) {
        log.error(e.getMessage(), e);
        this.errorMessage = e.getMessage();
        ok = false;
    } finally {
    }
    return ok;
}

Output:
         this.errorMessage = e.getMessage();
-        String unableDirectQueryStr = "String_Node_Str";
-        if (getErrorMessage().contains(unableDirectQueryStr)) {
-            String sqlModeUnsupportedStr = Messages.getString("String_Node_Str");
-            String refactoredErrorMessage = StringUtils.replace(getErrorMessage(), unableDirectQueryStr, sqlModeUnsupportedStr, -1);
-            setError(refactoredErrorMessage);
+        if (this.errorMessage.contains("String_Node_Str")) {
+            this.errorMessage = Messages.getString("String_Node_Str");
         }


Input:
public void testFirstDayOfFiscalMonth() throws BirtException {
    String[] scripts = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    Calendar c = Calendar.getInstance();
    c.clear();
    Date[] values = new Date[] { date(c, 2015, 5, 1), date(c, 2015, 5, 1), date(c, 2014, 7, 15), date(c, 2015, 6, 10), date(c, 2015, 5, 10), date(c, 2013, 11, 10), date(c, 2014, 0, 31), date(c, 2014, 8, 30) };
    for (int i = 0; i < values.length; i++) {
        Object result = cx.evaluateString(scope, scripts[i], "String_Node_Str", 1, null);
        assertEquals(String.valueOf(i), values[i], result);
    }
}

Output:
 public void testFirstDayOfFiscalMonth() throws BirtException {
-    String[] scripts = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
+    String[] scripts = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
     Calendar c = Calendar.getInstance();


Input:
public void finalizeRun() {
    if (entityManager != null) {
        if (entityManager != entityManagerLive.get() || controller != controllerLive.get()) {
            SpoutRegion r = (SpoutRegion) chunk.getRegion();
            r.removeEntity(this);
            if (entityManagerLive.get() == null) {
                controller.onDeath();
                if (controller instanceof PlayerController) {
                    Player p = ((PlayerController) controller).getPlayer();
                    p.getNetworkSynchronizer().onDeath();
                }
            }
        }
    }
    if (entityManagerLive.get() != null) {
        if (entityManager != entityManagerLive.get() || controller != controllerLive.get()) {
            entityManagerLive.get().allocate(this);
        }
    }
    if (chunkLive.get() != chunk) {
        if (chunkLive.get() != null) {
            ((SpoutChunk) chunkLive.get()).addEntity(this);
            if (observer) {
                chunkLive.get().refreshObserver(this);
            }
        }
        if (chunk != null && chunk.isLoaded()) {
            ((SpoutChunk) chunk).removeEntity(this);
            if (observer) {
                chunk.removeObserver(this);
            }
        }
        if (chunkLive.get() == null) {
            if (chunk != null && chunk.isLoaded()) {
                ((SpoutChunk) chunk).removeEntity(this);
                if (observer) {
                    chunk.removeObserver(this);
                }
            }
            if (entityManagerLive.get() != null) {
                entityManagerLive.get().deallocate(this);
            }
        }
    }
    if (observerLive.get() != observer) {
        observer = !observer;
        if (observer) {
            chunkLive.get().refreshObserver(this);
        } else {
            chunkLive.get().removeObserver(this);
        }
    }
}

Output:
             r.removeEntity(this);
-            if (entityManagerLive.get() == null) {
+            if (isDead()) {
                 controller.onDeath();


Input:
public int hashCode() {
    return (producerId == null) ? 0 : producerId.hashCode();
}

Output:
 public int hashCode() {
-    return (producerId == null) ? 0 : producerId.hashCode();
+    return (producerId == null) ? super.hashCode() : producerId.hashCode();
 }


Input:
private void parseForecast(JSONObject root, Weather weather) throws JSONException {
    JSONObject forecast1 = getObject("String_Node_Str", root);
    JSONObject simpleForecast = getObject("String_Node_Str", forecast1);
    JSONArray jArr = simpleForecast.getJSONArray("String_Node_Str");
    for (int i = 0; i < jArr.length(); i++) {
        JSONObject dayForecast = jArr.getJSONObject(i);
        DayForecast df = new DayForecast();
        JSONObject jsonDate = dayForecast.getJSONObject("String_Node_Str");
        df.timestamp = jsonDate.getLong("String_Node_Str");
        df.weather.currentCondition.setDescr(dayForecast.getString("String_Node_Str"));
        df.weather.currentCondition.setIcon(dayForecast.getString("String_Node_Str"));
        if (codeProvider != null)
            df.weather.currentCondition.setWeatherCode(codeProvider.getWeatherCode(df.weather.currentCondition.getIcon()));
        if (WeatherUtility.isMetric(config.unitSystem)) {
            df.forecastTemp.max = dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str");
            df.forecastTemp.min = dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str");
            df.weather.wind.setSpeed(dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str"));
            df.weather.snow.setTime("String_Node_Str");
            df.weather.snow.setAmmount(dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str"));
            df.weather.rain[0].setTime("String_Node_Str");
            df.weather.rain[0].setAmmount(dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str"));
        } else {
            df.forecastTemp.max = dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str");
            df.forecastTemp.min = dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str");
            df.weather.wind.setSpeed(dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str"));
            df.weather.snow.setTime("String_Node_Str");
            df.weather.snow.setAmmount(dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str"));
            df.weather.rain[0].setTime("String_Node_Str");
            df.weather.rain[0].setAmmount(dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str"));
        }
        df.weather.wind.setDeg(dayForecast.getJSONObject("String_Node_Str").getInt("String_Node_Str"));
        if (i == 0 && weather != null) {
            weather.temperature.setMinTemp(df.forecastTemp.min);
            weather.temperature.setMaxTemp(df.forecastTemp.max);
        }
        forecast.addForecast(df);
    }
    forecast.setUnit(units);
}

Output:
         df.weather.currentCondition.setIcon(dayForecast.getString("String_Node_Str"));
-        if (codeProvider != null)
-            df.weather.currentCondition.setWeatherCode(codeProvider.getWeatherCode(df.weather.currentCondition.getIcon()));
+        if (codeProvider != null) {
+            try {
+                df.weather.currentCondition.setWeatherCode(codeProvider.getWeatherCode(df.weather.currentCondition.getIcon()));
+            } catch (Throwable t) {
+                df.weather.currentCondition.setWeatherCode(WeatherCode.NOT_AVAILABLE);
+            }
+        }
         if (WeatherUtility.isMetric(config.unitSystem)) {


Input:
private final Activity performLaunchActivity(ActivityRecord r, Intent customIntent) {
    ActivityInfo aInfo = r.activityInfo;
    if (r.packageInfo == null) {
        r.packageInfo = getPackageInfo(aInfo.applicationInfo, Context.CONTEXT_INCLUDE_CODE);
    }
    ComponentName component = r.intent.getComponent();
    if (component == null) {
        component = r.intent.resolveActivity(mInitialApplication.getPackageManager());
        r.intent.setComponent(component);
    }
    if (r.activityInfo.targetActivity != null) {
        component = new ComponentName(r.activityInfo.packageName, r.activityInfo.targetActivity);
    }
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
        r.intent.setExtrasClassLoader(cl);
        if (r.state != null) {
            r.state.setClassLoader(cl);
        }
    } catch (Exception e) {
        if (!mInstrumentation.onException(activity, e)) {
            throw new RuntimeException("String_Node_Str" + component + "String_Node_Str" + e.toString(), e);
        }
    }
    try {
        Application app = r.packageInfo.makeApplication(false);
        if (localLOGV)
            Log.v(TAG, "String_Node_Str" + r);
        if (localLOGV)
            Log.v(TAG, r + "String_Node_Str" + app + "String_Node_Str" + app.getPackageName() + "String_Node_Str" + r.packageInfo.getPackageName() + "String_Node_Str" + r.intent.getComponent().toShortString() + "String_Node_Str" + r.packageInfo.getAppDir());
        if (activity != null) {
            ApplicationContext appContext = new ApplicationContext();
            appContext.init(r.packageInfo, r.token, this);
            appContext.setOuterContext(activity);
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config = new Configuration(mConfiguration);
            if (DEBUG_CONFIGURATION)
                Log.v(TAG, "String_Node_Str" + r.activityInfo.name + "String_Node_Str" + config);
            activity.attach(appContext, this, getInstrumentation(), r.token, r.ident, app, r.intent, r.activityInfo, title, r.parent, r.embeddedID, r.lastNonConfigurationInstance, r.lastNonConfigurationChildInstances, config);
            if (customIntent != null) {
                activity.mIntent = customIntent;
            }
            r.lastNonConfigurationInstance = null;
            r.lastNonConfigurationChildInstances = null;
            activity.mStartedActivity = false;
            int theme = r.activityInfo.getThemeResource();
            if (theme != 0) {
                activity.setTheme(theme);
            }
            activity.mCalled = false;
            mInstrumentation.callActivityOnCreate(activity, r.state);
            if (!activity.mCalled) {
                throw new SuperNotCalledException("String_Node_Str" + r.intent.getComponent().toShortString() + "String_Node_Str");
            }
            r.activity = activity;
            r.stopped = true;
            if (!r.activity.mFinished) {
                activity.performStart();
                r.stopped = false;
            }
            if (!r.activity.mFinished) {
                if (r.state != null) {
                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                }
            }
            if (!r.activity.mFinished) {
                activity.mCalled = false;
                mInstrumentation.callActivityOnPostCreate(activity, r.state);
                if (!activity.mCalled) {
                    throw new SuperNotCalledException("String_Node_Str" + r.intent.getComponent().toShortString() + "String_Node_Str");
                }
            }
            r.state = null;
        }
        r.paused = true;
        mActivities.put(r.token, r);
    } catch (SuperNotCalledException e) {
        throw e;
    } catch (Exception e) {
        if (!mInstrumentation.onException(activity, e)) {
            throw new RuntimeException("String_Node_Str" + component + "String_Node_Str" + e.toString(), e);
        }
    }
    return activity;
}

Output:
     try {
-        Application app = r.packageInfo.makeApplication(false);
+        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
         if (localLOGV)


Input:
public static String graphDirectory() {
    return config.getString(GRAPH_DIRECTORY_KEY);
}

Output:
 public static String graphDirectory() {
-    return config.getString(GRAPH_DIRECTORY_KEY);
+    return config.getString(CONFIG_GRAPH_DIRECTORY);
 }


Input:
public boolean apply(Game game, Ability source) {
    Card sourceCard = game.getCard(source.getSourceId());
    if (sourceCard == null) {
        return false;
    }
    for (Player player : game.getPlayers().values()) {
        if (player.getLibrary().size() > 0) {
            Card card = player.getLibrary().removeFromTop(game);
            if (card != null) {
                Cards cards = new CardsImpl();
                cards.add(card);
                player.revealCards(sourceCard.getName() + "String_Node_Str" + player.getName(), cards, game);
                player.loseLife(card.getConvertedManaCost(), game);
                card.moveToZone(Zone.HAND, source.getSourceId(), game, true);
            }
        }
    }
    return true;
}

Output:
                 player.revealCards(sourceCard.getName() + "String_Node_Str" + player.getName(), cards, game);
-                player.loseLife(card.getConvertedManaCost(), game);
+                player.loseLife(card.getConvertedManaCost(), game, false);
                 card.moveToZone(Zone.HAND, source.getSourceId(), game, true);


Input:
public static int forChampionListDto(final ChampionList champions) {
    return Arrays.hashCode(new Object[] { ChampionList.class.getCanonicalName(), champions.getPlatform(), champions.getVersion(), champions.getLocale(), champions.getIncludedData() });
}

Output:
 public static int forChampionListDto(final ChampionList champions) {
-    return Arrays.hashCode(new Object[] { ChampionList.class.getCanonicalName(), champions.getPlatform(), champions.getVersion(), champions.getLocale(), champions.getIncludedData() });
+    return Arrays.hashCode(new Object[] { ChampionList.class.getCanonicalName(), champions.getPlatform(), champions.getVersion(), champions.getLocale(), champions.getIncludedData(), champions.isDataById() });
 }


Input:
private ScalingProcessTask<?, ?> removeFromLoadBalancerOrTerminate(final AutoScalingGroupScalingView group, final int currentCapacity, final List<String> registeredInstances, final List<ActivityCause> causes, final boolean replace) {
    final ScalingProcessTask<?, ?> task;
    if (group.getLoadBalancerNames().isEmpty()) {
        transitionToDeregistered(group, registeredInstances);
        task = new TerminateInstancesScalingProcessTask(group, currentCapacity, registeredInstances, causes, replace, true, true);
    } else {
        task = new RemoveFromLoadBalancerScalingProcessTask(group, currentCapacity, registeredInstances, causes, replace);
    }
    return task;
}

Output:
     final ScalingProcessTask<?, ?> task;
-    if (group.getLoadBalancerNames().isEmpty()) {
+    if (group.getLoadBalancerNames().isEmpty() || !anyRegisteredInstances) {
         transitionToDeregistered(group, registeredInstances);


Input:
public boolean equals(Object that) {
    if (that == null && this.getClass() != that.getClass()) {
        return false;
    }
    JsArrayLiteral thatLiteral = (JsArrayLiteral) that;
    return internable == thatLiteral.internable && exprs.equals(thatLiteral.exprs);
}

Output:
 public boolean equals(Object that) {
-    if (that == null && this.getClass() != that.getClass()) {
+    if (that == null || this.getClass() != that.getClass()) {
         return false;


Input:
public void animatingWindowLw(WindowState win, WindowManager.LayoutParams attrs) {
    if (mTopFullscreenOpaqueWindowState == null && win.isVisibleOrBehindKeyguardLw()) {
        if ((attrs.flags & FLAG_FORCE_NOT_FULLSCREEN) != 0) {
            mForceStatusBar = true;
        }
        if (attrs.type >= FIRST_APPLICATION_WINDOW && attrs.type <= LAST_APPLICATION_WINDOW && win.fillsScreenLw(mW, mH, false, false)) {
            if (DEBUG_LAYOUT)
                Log.v(TAG, "String_Node_Str" + win);
            mTopFullscreenOpaqueWindowState = win;
            if ((attrs.flags & FLAG_SHOW_WHEN_LOCKED) != 0) {
                if (localLOGV)
                    Log.v(TAG, "String_Node_Str" + win);
                mHideLockScreen = true;
            }
            if ((attrs.flags & FLAG_DISMISS_KEYGUARD) != 0) {
                if (localLOGV)
                    Log.v(TAG, "String_Node_Str" + win);
                mDismissKeyguard = true;
            }
            if ((attrs.flags & FLAG_ALLOW_LOCK_WHILE_SCREEN_ON) != 0) {
                mAllowLockscreenWhenOn = true;
            }
        }
    }
}

Output:
         }
-        if (attrs.type >= FIRST_APPLICATION_WINDOW && attrs.type <= LAST_APPLICATION_WINDOW && win.fillsScreenLw(mW, mH, false, false)) {
+        if (attrs.type >= FIRST_APPLICATION_WINDOW && attrs.type <= LAST_APPLICATION_WINDOW && attrs.x == 0 && attrs.y == 0 && attrs.width == WindowManager.LayoutParams.MATCH_PARENT && attrs.height == WindowManager.LayoutParams.MATCH_PARENT) {
             if (DEBUG_LAYOUT)


Input:
private BufferedReader getConfigFile() throws JSchException, IOException {
    InputStream in = null;
    JSch jsch = new JSch();
    Session session = jsch.getSession(host.getUser(), host.getAddress().getHostAddress(), SSH_PORT);
    session.setPassword(host.getPass());
    session.setConfig("String_Node_Str", "String_Node_Str");
    session.connect();
    Channel channel = session.openChannel("String_Node_Str");
    ((ChannelExec) channel).setCommand(GET_ALL_CONFIG);
    in = channel.getInputStream();
    channel.connect();
    return new BufferedReader(new InputStreamReader(in));
}

Output:
     session.connect();
-    Channel channel = session.openChannel("String_Node_Str");
-    ((ChannelExec) channel).setCommand(GET_ALL_CONFIG);
-    in = channel.getInputStream();
-    channel.connect();
+    if (host.usesEnable()) {
+        Channel channel = session.openChannel("String_Node_Str");
+        ((ChannelExec) channel).setCommand(ENABLE_SUPERUSER);
+        in = channel.getInputStream();
+        OutputStream outputStream = channel.getOutputStream();
+        channel.connect();
+        outputStream.write((host.getEnablePass() + "String_Node_Str").getBytes());
+        outputStream.flush();
+        outputStream.write(DISABLE_OUTPUT_BUFFERING.getBytes());
+        outputStream.flush();
+        outputStream.write(GET_ALL_CONFIG.getBytes());
+        outputStream.flush();
+    } else {
+        Channel channel = session.openChannel("String_Node_Str");
+        ((ChannelExec) channel).setCommand(DISABLE_OUTPUT_BUFFERING);
+        in = channel.getInputStream();
+        OutputStream outputStream = channel.getOutputStream();
+        channel.connect();
+        outputStream.write(GET_ALL_CONFIG.getBytes());
+        outputStream.flush();
+    }
     return new BufferedReader(new InputStreamReader(in));


Input:
public void afterComponentAttached(Component comp, Page page) {
    if (comp.getDesktop() != null) {
        final Binder selfBinder = (Binder) comp.getAttribute(BinderImpl.BINDER);
        if (selfBinder == null) {
            final Binder binder = (Binder) comp.getAttribute(BinderImpl.BINDER, true);
            if (binder != null) {
                comp.addEventListener(10000, BinderImpl.ON_BIND_INIT, new EventListener<Event>() {
                    public void onEvent(Event event) throws Exception {
                        final Component comp = event.getTarget();
                        comp.removeEventListener(BinderImpl.ON_BIND_INIT, this);
                        if (comp.getParent() == null || comp.getPage() == null) {
                            return;
                        }
                        final Binder innerBinder = (Binder) comp.getAttribute(BinderImpl.BINDER);
                        if (innerBinder != null) {
                            return;
                        }
                        new AnnotateBinderHelper(binder).initComponentBindings(comp);
                        binder.loadComponent(comp, true);
                        if (comp.getAttribute(BinderImpl.VAR) != null)
                            comp.setAttribute(BinderImpl.BINDER, binder);
                    }
                });
                Events.postEvent(new Event(BinderImpl.ON_BIND_INIT, comp));
            }
        }
    }
}

Output:
             final Binder binder = (Binder) comp.getAttribute(BinderImpl.BINDER, true);
-            if (binder != null) {
+            if (binder != null && (binder instanceof AnnotateBinder)) {
                 comp.addEventListener(10000, BinderImpl.ON_BIND_INIT, new EventListener<Event>() {


Input:
private void processSpeechQueue() {
    boolean speechQueueAvailable = false;
    try {
        speechQueueAvailable = speechQueueLock.tryLock();
        if (!speechQueueAvailable) {
            return;
        }
        if (mSpeechQueue.size() < 1) {
            mIsSpeaking = false;
            broadcastTtsQueueProcessingCompleted();
            return;
        }
        mCurrentSpeechItem = mSpeechQueue.get(0);
        mIsSpeaking = true;
        SoundResource sr = getSoundResource(mCurrentSpeechItem);
        Log.i("String_Node_Str", "String_Node_Str" + mCurrentSpeechItem.mText);
        if (sr == null) {
            if (mCurrentSpeechItem.mType == SpeechItem.TEXT) {
                mCurrentSpeechItem = splitCurrentTextIfNeeded(mCurrentSpeechItem);
                speakInternalOnly(mCurrentSpeechItem);
            } else if (mCurrentSpeechItem.mType == SpeechItem.TEXT_TO_FILE) {
                synthToFileInternalOnly(mCurrentSpeechItem);
            } else {
                silence(mCurrentSpeechItem);
            }
        } else {
            cleanUpPlayer();
            if (sr.mSourcePackageName == PKGNAME) {
                mPlayer = MediaPlayer.create(this, sr.mResId);
            } else if (sr.mSourcePackageName != null) {
                Context ctx;
                try {
                    ctx = this.createPackageContext(sr.mSourcePackageName, 0);
                } catch (NameNotFoundException e) {
                    e.printStackTrace();
                    mSpeechQueue.remove(0);
                    mIsSpeaking = false;
                    return;
                }
                mPlayer = MediaPlayer.create(ctx, sr.mResId);
            } else {
                mPlayer = MediaPlayer.create(this, Uri.parse(sr.mFilename));
            }
            if (mPlayer == null) {
                mSpeechQueue.clear();
                mIsSpeaking = false;
                return;
            }
            mPlayer.setOnCompletionListener(this);
            try {
                mPlayer.setAudioStreamType(getStreamTypeFromParams(mCurrentSpeechItem.mParams));
                mPlayer.start();
            } catch (IllegalStateException e) {
                mSpeechQueue.clear();
                mIsSpeaking = false;
                cleanUpPlayer();
                return;
            }
        }
        if (mSpeechQueue.size() > 0) {
            mSpeechQueue.remove(0);
        }
    } finally {
        if (speechQueueAvailable) {
            speechQueueLock.unlock();
        }
    }
}

Output:
     try {
-        speechQueueAvailable = speechQueueLock.tryLock();
+        speechQueueAvailable = speechQueueLock.tryLock(SPEECHQUEUELOCK_TIMEOUT, TimeUnit.MILLISECONDS);
         if (!speechQueueAvailable) {


Input:
public static void onCurrencyAdd(CurrencyAddEvent event) {
    UUID target = event.getTarget();
    if (!NameManager.isAdminShop(target) || SERVER_ECONOMY_ACCOUNT.equals(NameManager.getUsername(target))) {
        return;
    }
    if (SERVER_ECONOMY_ACCOUNT.isEmpty()) {
        event.setAdded(true);
        return;
    } else {
        Account account = NameManager.getAccount(SERVER_ECONOMY_ACCOUNT);
        if (account == null || account.getUuid() == null) {
            return;
        }
        target = account.getUuid();
    }
    event.setAdded(true);
    if (target == null) {
        return;
    }
    CurrencyAddEvent currencyAddEvent = new CurrencyAddEvent(event.getAmount(), target, event.getWorld());
    ChestShop.callEvent(currencyAddEvent);
}

Output:
     UUID target = event.getTarget();
-    if (!NameManager.isAdminShop(target) || SERVER_ECONOMY_ACCOUNT.equals(NameManager.getUsername(target))) {
+    if (!NameManager.isAdminShop(target) || NameManager.isServerEconomyAccount(target)) {
         return;


Input:
public char getCharacter(DelayedCellSetter<T, ?>[] target) throws Exception {
    return ((CharDelayedCellSetter<T>) target[index]).getCharacter();
}

Output:
 public char getCharacter(DelayedCellSetter<T, ?>[] target) throws Exception {
-    return ((CharDelayedCellSetter<T>) target[index]).getCharacter();
+    return ((CharDelayedCellSetter<T>) target[index]).consumeCharacter();
 }


Input:
public static boolean isPropertyType(final Class type) {
    if (type == null) {
        return false;
    }
    return isPrimitiveLike(type) || (type == DBRef.class) || (type == Pattern.class) || (type == CodeWScope.class) || (type == ObjectId.class) || (type == Key.class);
}

Output:
     }
-    return isPrimitiveLike(type) || (type == DBRef.class) || (type == Pattern.class) || (type == CodeWScope.class) || (type == ObjectId.class) || (type == Key.class);
+    return isPrimitiveLike(type) || (type == DBRef.class) || (type == Pattern.class) || (type == CodeWScope.class) || (type == ObjectId.class) || (type == Key.class) || (type == DBObject.class) || (type == BasicDBObject.class);
 }


Input:
protected int[] formalize(DimensionType[] columns, int tableWidth, boolean isTableWidthDefined) {
    ArrayList percentageList = new ArrayList();
    ArrayList unsetList = new ArrayList();
    ArrayList preFixedList = new ArrayList();
    int[] resolvedColumnWidth = new int[columns.length];
    double total = 0.0f;
    int fixedLength = 0;
    for (int i = 0; i < columns.length; i++) {
        if (columns[i] == null) {
            unsetList.add(new Integer(i));
        } else if (EngineIRConstants.UNITS_PERCENTAGE.equals(columns[i].getUnits())) {
            percentageList.add(new Integer(i));
            total += columns[i].getMeasure();
        } else if (EngineIRConstants.UNITS_EM.equals(columns[i].getUnits()) || EngineIRConstants.UNITS_EX.equals(columns[i].getUnits())) {
            int len = TableLayout.this.getDimensionValue(columns[i], PropertyUtil.getDimensionValue(table.getComputedStyle().getProperty(StyleConstants.STYLE_FONT_SIZE)));
            resolvedColumnWidth[i] = len;
            fixedLength += len;
        } else {
            int len = TableLayout.this.getDimensionValue(columns[i], tableWidth);
            resolvedColumnWidth[i] = len;
            preFixedList.add(new Integer(i));
            fixedLength += len;
        }
    }
    if (!isTableWidthDefined && unsetList.isEmpty() && percentageList.isEmpty()) {
        return resolvedColumnWidth;
    }
    if (fixedLength >= tableWidth) {
        for (int i = 0; i < unsetList.size(); i++) {
            Integer index = (Integer) unsetList.get(i);
            resolvedColumnWidth[index.intValue()] = 0;
        }
        for (int i = 0; i < percentageList.size(); i++) {
            Integer index = (Integer) percentageList.get(i);
            resolvedColumnWidth[index.intValue()] = 0;
        }
        return resolvedColumnWidth;
    }
    if (unsetList.isEmpty()) {
        if (percentageList.isEmpty()) {
            int left = tableWidth - fixedLength;
            int delta = left / preFixedList.size();
            for (int i = 0; i < preFixedList.size(); i++) {
                Integer index = (Integer) preFixedList.get(i);
                resolvedColumnWidth[index.intValue()] += delta;
            }
        } else {
            float leftPercentage = (((float) (tableWidth - fixedLength)) / tableWidth) * 100.0f;
            double ratio = leftPercentage / total;
            for (int i = 0; i < percentageList.size(); i++) {
                Integer index = (Integer) percentageList.get(i);
                columns[index.intValue()] = new DimensionType(columns[index.intValue()].getMeasure() * ratio, columns[index.intValue()].getUnits());
                resolvedColumnWidth[index.intValue()] = TableLayout.this.getDimensionValue(columns[index.intValue()], tableWidth);
            }
        }
    } else {
        if (percentageList.isEmpty()) {
            int left = tableWidth - fixedLength;
            int eachWidth = left / unsetList.size();
            for (int i = 0; i < unsetList.size(); i++) {
                Integer index = (Integer) unsetList.get(i);
                resolvedColumnWidth[index.intValue()] = eachWidth;
            }
        } else {
            float leftPercentage = (((float) (tableWidth - fixedLength)) / tableWidth) * 100.0f;
            if (leftPercentage <= total) {
                double ratio = leftPercentage / total;
                for (int i = 0; i < unsetList.size(); i++) {
                    Integer index = (Integer) unsetList.get(i);
                    resolvedColumnWidth[index.intValue()] = 0;
                }
                for (int i = 0; i < percentageList.size(); i++) {
                    Integer index = (Integer) percentageList.get(i);
                    columns[index.intValue()] = new DimensionType(columns[index.intValue()].getMeasure() * ratio, columns[index.intValue()].getUnits());
                    resolvedColumnWidth[index.intValue()] = TableLayout.this.getDimensionValue(columns[index.intValue()], tableWidth);
                }
            } else {
                int usedLength = fixedLength;
                for (int i = 0; i < percentageList.size(); i++) {
                    Integer index = (Integer) percentageList.get(i);
                    int width = TableLayout.this.getDimensionValue(columns[index.intValue()], tableWidth);
                    usedLength += width;
                    resolvedColumnWidth[index.intValue()] = width;
                }
                int left = tableWidth - usedLength;
                int eachWidth = left / unsetList.size();
                for (int i = 0; i < unsetList.size(); i++) {
                    Integer index = (Integer) unsetList.get(i);
                    resolvedColumnWidth[index.intValue()] = eachWidth;
                }
            }
        }
    }
    return resolvedColumnWidth;
}

Output:
             int left = tableWidth - fixedLength;
-            int delta = left / preFixedList.size();
-            for (int i = 0; i < preFixedList.size(); i++) {
-                Integer index = (Integer) preFixedList.get(i);
-                resolvedColumnWidth[index.intValue()] += delta;
+            if (!preFixedList.isEmpty()) {
+                int delta = left / preFixedList.size();
+                for (int i = 0; i < preFixedList.size(); i++) {
+                    Integer index = (Integer) preFixedList.get(i);
+                    resolvedColumnWidth[index.intValue()] += delta;
+                }
             }


Input:
public static void setup() throws Exception {
    CConfiguration conf = CConfiguration.create();
    conf.set(Constants.CFG_HDFS_USER, System.getProperty("String_Node_Str"));
    Injector injector = Guice.createInjector(new DataFabricDistributedModule(), new ConfigModule(conf, TEST_HBASE.getConfiguration()), new ZKClientModule(), new DiscoveryRuntimeModule().getDistributedModules(), new TransactionMetricsModule(), new LocationRuntimeModule().getDistributedModules(), new NamespaceClientUnitTestModule().getModule(), new SystemDatasetRuntimeModule().getDistributedModules(), new DataSetsModules().getInMemoryModules(), new AuthorizationTestModule(), new AuthorizationEnforcementModule().getInMemoryModules(), new AuthenticationContextModules().getNoOpModule(), new AbstractModule() {

        protected void configure() {
            bind(UGIProvider.class).to(UnsupportedUGIProvider.class);
            bind(OwnerAdmin.class).to(DefaultOwnerAdmin.class);
        }
    });
    dsFramework = injector.getInstance(DatasetFramework.class);
    tableUtil = injector.getInstance(HBaseTableUtil.class);
    ddlExecutor = new HBaseDDLExecutorFactory(conf, TEST_HBASE.getHBaseAdmin().getConfiguration()).get();
    ddlExecutor.createNamespaceIfNotExists(tableUtil.getHBaseNamespace(NamespaceId.SYSTEM));
}

Output:
     conf.set(Constants.CFG_HDFS_USER, System.getProperty("String_Node_Str"));
-    Injector injector = Guice.createInjector(new DataFabricDistributedModule(), new ConfigModule(conf, TEST_HBASE.getConfiguration()), new ZKClientModule(), new DiscoveryRuntimeModule().getDistributedModules(), new TransactionMetricsModule(), new LocationRuntimeModule().getDistributedModules(), new NamespaceClientUnitTestModule().getModule(), new SystemDatasetRuntimeModule().getDistributedModules(), new DataSetsModules().getInMemoryModules(), new AuthorizationTestModule(), new AuthorizationEnforcementModule().getInMemoryModules(), new AuthenticationContextModules().getNoOpModule(), new AbstractModule() {
+    Injector injector = Guice.createInjector(new DataFabricModules().getDistributedModules(), new ConfigModule(conf, TEST_HBASE.getConfiguration()), new ZKClientModule(), new DiscoveryRuntimeModule().getDistributedModules(), new TransactionMetricsModule(), new LocationRuntimeModule().getDistributedModules(), new NamespaceClientUnitTestModule().getModule(), new SystemDatasetRuntimeModule().getDistributedModules(), new DataSetsModules().getInMemoryModules(), new AuthorizationTestModule(), new AuthorizationEnforcementModule().getInMemoryModules(), new AuthenticationContextModules().getNoOpModule(), new AbstractModule() {


Input:
public static <ModelClass extends Model> void loadFromCursor(JSONModel<ModelClass> jsonModel, Cursor cursor) {
    Set<Field> fields = jsonModel.mTableStructure.getColumns();
    for (Field field : fields) {
        Object value = SqlUtils.getModelValueFromCursor(cursor, jsonModel.mTableStructure, field);
        if (value != null) {
            try {
                jsonModel.mJson.put(jsonModel.mTableStructure.getColumnName(field), value);
            } catch (JSONException e) {
                FlowLog.logError(e);
            }
        }
    }
}

Output:
     for (Field field : fields) {
-        Object value = SqlUtils.getModelValueFromCursor(cursor, jsonModel.mTableStructure, field);
+        Object value = SqlUtils.getModelValueFromCursor(cursor, jsonModel.mTableStructure, field, jsonModel.mTableStructure.getColumnName(field), field.getType());
         if (value != null) {


Input:
void initUI() {
    mViewPagerAdapter = new ChapterFragmentPagerAdapter(this, getSupportFragmentManager(), selectedChapterId);
    mViewPager.setAdapter(mViewPagerAdapter);
    mViewPager.setOffscreenPageLimit(3);
    updateSelectionFor(findChapterById(selectedChapterId));
    recordStartPageView();
    mTabLayout.setupWithViewPager(mViewPager);
    if (SECTION_EVENTS.equals(getIntent().getStringExtra(Const.EXTRA_SECTION))) {
        mHandler.postDelayed(new Runnable() {
            public void run() {
                mViewPager.setCurrentItem(2, true);
            }
        }, 500);
    }
}

Output:
     mViewPager.setOffscreenPageLimit(3);
-    updateSelectionFor(findChapterById(selectedChapterId));
+    Chapter selectedChapter = findChapterById(selectedChapterId);
+    if (selectedChapter != null) {
+        updateSelectionFor(selectedChapter);
+    }
     recordStartPageView();


Input:
protected static Property createComplex(final String name, final Property... properties) {
    ComplexValue complexValue = new ComplexValue();
    for (final Property property : properties) {
        complexValue.getValue().add(property);
    }
    return new Property(null, name, ValueType.COMPLEX, complexValue);
}

Output:
     }
-    return new Property(null, name, ValueType.COMPLEX, complexValue);
+    return new Property(type, name, ValueType.COMPLEX, complexValue);
 }


Input:
public static String getString(final byte[] bytes, final int offset, final int length) {
    try {
        return length == 0 ? null : new String(bytes, offset, Math.min(length, bytes.length - offset), "String_Node_Str");
    } catch (UnsupportedEncodingException e) {
        throw new Error("String_Node_Str" + e.getMessage());
    }
}

Output:
     try {
-        return length == 0 ? null : new String(bytes, offset, Math.min(length, bytes.length - offset), "String_Node_Str");
+        return new String(bytes, offset, Math.min(length, bytes.length - offset), "String_Node_Str");
     } catch (UnsupportedEncodingException e) {


Input:
public void getComponent(Composite parent) {
    init();
    cmpContent = new Composite(parent, SWT.NONE);
    {
        GridLayout glContent = new GridLayout();
        cmpContent.setLayout(glContent);
        GridData gd = new GridData(GridData.FILL_BOTH);
        cmpContent.setLayoutData(gd);
    }
    Composite cmpBasic = new Composite(cmpContent, SWT.NONE);
    {
        cmpBasic.setLayout(new GridLayout(3, false));
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        cmpBasic.setLayoutData(gd);
    }
    Label lblTitle = new Label(cmpBasic, SWT.NONE);
    {
        lblTitle.setText(Messages.getString("String_Node_Str"));
    }
    List keys = null;
    if (getContext().getUIServiceProvider() != null) {
        keys = getContext().getUIServiceProvider().getRegisteredKeys();
    }
    txtTitle = new ExternalizedTextEditorComposite(cmpBasic, SWT.BORDER, -1, -1, keys, getContext().getUIServiceProvider(), getChart().getTitle().getLabel().getCaption().getValue());
    {
        GridData gdTXTTitle = new GridData(GridData.FILL_HORIZONTAL);
        txtTitle.setLayoutData(gdTXTTitle);
        txtTitle.setEnabled(getChart().getTitle().isVisible());
        txtTitle.addListener(this);
    }
    btnVisible = new Button(cmpBasic, SWT.CHECK);
    {
        btnVisible.setText(Messages.getString("String_Node_Str"));
        btnVisible.setSelection(getChart().getTitle().isVisible());
        btnVisible.addSelectionListener(this);
    }
    Label lblBackground = new Label(cmpBasic, SWT.NONE);
    lblBackground.setText(Messages.getString("String_Node_Str"));
    cmbBackground = new FillChooserComposite(cmpBasic, SWT.NONE, getChart().getBlock().getBackground(), true, true);
    {
        GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
        cmbBackground.setLayoutData(gridData);
        cmbBackground.addListener(this);
    }
    new Label(cmpBasic, SWT.NONE);
    new Label(cmpBasic, SWT.NONE).setText(Messages.getString("String_Node_Str"));
    cmbStyle = new Combo(cmpBasic, SWT.DROP_DOWN | SWT.READ_ONLY);
    {
        GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
        cmbStyle.setLayoutData(gridData);
        cmbStyle.addSelectionListener(this);
    }
    btnEnablePreview = new Button(cmpBasic, SWT.CHECK);
    {
        btnEnablePreview.setText(Messages.getString("String_Node_Str"));
        btnEnablePreview.setSelection(ChartPreviewPainter.isProcessorEnabled());
        btnEnablePreview.addSelectionListener(this);
    }
    Group cmpInteractivity = new Group(cmpBasic, SWT.NONE);
    {
        GridLayout gl = new GridLayout(2, false);
        cmpInteractivity.setLayout(gl);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        gd.horizontalSpan = 2;
        cmpInteractivity.setLayoutData(gd);
        cmpInteractivity.setText(Messages.getString("String_Node_Str"));
    }
    btnEnable = new Button(cmpInteractivity, SWT.CHECK);
    {
        GridData gridData = new GridData();
        gridData.horizontalSpan = 2;
        btnEnable.setLayoutData(gridData);
        btnEnable.setText(Messages.getString("String_Node_Str"));
        btnEnable.setSelection(getChart().getInteractivity().isEnable());
        btnEnable.addSelectionListener(this);
    }
    lblLegendBehavior = new Label(cmpInteractivity, SWT.NONE);
    {
        lblLegendBehavior.setText(Messages.getString("String_Node_Str"));
    }
    cmbInteractivity = new Combo(cmpInteractivity, SWT.DROP_DOWN | SWT.READ_ONLY);
    {
        GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
        cmbInteractivity.setLayoutData(gridData);
        cmbInteractivity.addSelectionListener(this);
    }
    btnTitleTriggers = new Button(cmpInteractivity, SWT.PUSH);
    {
        btnTitleTriggers.setText(Messages.getString("String_Node_Str"));
        btnTitleTriggers.addSelectionListener(this);
    }
    btnChartAreaTriggers = new Button(cmpInteractivity, SWT.PUSH);
    {
        btnChartAreaTriggers.setText(Messages.getString("String_Node_Str"));
        btnChartAreaTriggers.addSelectionListener(this);
    }
    enableInteractivity(btnEnable.getSelection());
    populateLists();
    createButtonGroup(cmpContent);
}

Output:
         txtTitle.setLayoutData(gdTXTTitle);
-        txtTitle.setEnabled(getChart().getTitle().isVisible());
+        if (!getChart().getTitle().isVisible())
+            txtTitle.setEnabled(false);
         txtTitle.addListener(this);


Input:
public void testGreaterThanOrEqual() throws Exception {
    FilterDescriptor idFilter = new FilterDescriptor(FilterCondition.AND, "String_Node_Str", FilterOperator.GREATER_THAN_OR_EQUAL, 2);
    ParamExpression paramExpression = mybatisQueryProvider.getWhereExpression(ProductView.class, idFilter);
    Map<String, Object> queryParams = new HashMap<>();
    queryParams.putAll(paramExpression.getParamMap());
    queryParams.put("String_Node_Str", paramExpression.getExpression());
    List<ProductView> productViews = northwindDao.getProductViewsByDynamic(queryParams);
    assertEquals(true, productViews.stream().allMatch(x -> x.getProductID() >= 2));
}

Output:
     FilterDescriptor idFilter = new FilterDescriptor(FilterCondition.AND, "String_Node_Str", FilterOperator.GREATER_THAN_OR_EQUAL, 2);
-    ParamExpression paramExpression = mybatisQueryProvider.getWhereExpression(ProductView.class, idFilter);
+    ParamExpression paramExpression = MybatisQueryProvider.getWhereExpression(ProductView.class, idFilter);
     Map<String, Object> queryParams = new HashMap<>();


Input:
private void generateTimestamp(byte[] buffer, int offset, long date) {
    Calendar c = Calendar.getInstance();
    c.setTimeInMillis(date);
    buffer[offset + 0] = 0;
    buffer[offset + 1] = 0;
    buffer[offset + 2] = 0;
    buffer[offset + 3] = 0;
}

Output:
     c.setTimeInMillis(date);
-    buffer[offset + 0] = 0;
-    buffer[offset + 1] = 0;
-    buffer[offset + 2] = 0;
-    buffer[offset + 3] = 0;
+    buffer[offset + 1] = (byte) (((c.get(Calendar.YEAR) - 2000) << 1) | ((c.get(Calendar.MONTH) + 1) >> 3));
+    buffer[offset + 0] = (byte) (((((c.get(Calendar.MONTH) + 1) & 7) << 5) | c.get(Calendar.DAY_OF_MONTH)) & 0x0ff);
+    buffer[offset + 3] = (byte) c.get(Calendar.HOUR_OF_DAY);
+    buffer[offset + 2] = (byte) c.get(Calendar.MINUTE);
 }


Input:
public boolean finalizeStart(final VirtualMachineProfile profile, final long hostId, final Commands cmds, final ReservationContext context) {
    DomainRouterVO router = _routerDao.findById(profile.getId());
    for (Answer answer : cmds.getAnswers()) {
        if (!answer.getResult()) {
            String cmdClassName = answer.getClass().getCanonicalName().replace("String_Node_Str", "String_Node_Str");
            String errorMessage = "String_Node_Str" + cmdClassName + "String_Node_Str";
            String errorDetails = "String_Node_Str" + answer.getDetails() + "String_Node_Str" + answer.toString();
            _alertMgr.sendAlert(AlertService.AlertType.ALERT_TYPE_DOMAIN_ROUTER, router.getDataCenterId(), router.getPodIdToDeployIn(), errorMessage, errorDetails);
            s_logger.warn(errorMessage);
            return false;
        }
    }
    boolean result = true;
    final List<Network> guestNetworks = new ArrayList<Network>();
    final List<? extends Nic> routerNics = _nicDao.listByVmId(profile.getId());
    for (final Nic nic : routerNics) {
        final Network network = _networkModel.getNetwork(nic.getNetworkId());
        if (network.getTrafficType() == TrafficType.Guest) {
            guestNetworks.add(network);
            if (nic.getBroadcastUri().getScheme().equals("String_Node_Str")) {
                final NicProfile nicProfile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), 0, false, "String_Node_Str");
                result = setupDhcpForPvlan(true, router, router.getHostId(), nicProfile);
            }
        }
    }
    if (result) {
        GetDomRVersionAnswer versionAnswer = (GetDomRVersionAnswer) cmds.getAnswer("String_Node_Str");
        router.setTemplateVersion(versionAnswer.getTemplateVersion());
        router.setScriptsVersion(versionAnswer.getScriptsVersion());
        router = _routerDao.persist(router, guestNetworks);
    }
    return result;
}

Output:
         router.setScriptsVersion(versionAnswer.getScriptsVersion());
-        router = _routerDao.persist(router, guestNetworks);
+        _routerDao.persist(router, guestNetworks);
     }


Input:
public Short evaluate() {
    if (values.setDocument(docId) == 0) {
        return null;
    }
    return ((Long) values.nextValue()).shortValue();
}

Output:
 public Short evaluate() {
-    if (values.setDocument(docId) == 0) {
-        return null;
+    switch(values.setDocument(docId)) {
+        case 0:
+            return null;
+        case 1:
+            return ((Long) values.nextValue()).shortValue();
+        default:
+            throw new GroupByOnArrayUnsupportedException(columnName());
     }


Input:
public void execute(int pid, int rid, BimDatabaseSession bimDatabaseSession) throws UserException, BimDeadlockException, BimDatabaseException {
    EClass eClass = bimDatabaseSession.getEClassForName(type);
    if (eClass == null) {
        throw new UserException("String_Node_Str" + type + "String_Node_Str");
    }
    IdEObject eObject = (IdEObject) eClass.getEPackage().getEFactoryInstance().create(eClass);
    eObject.setOid(oid);
    eObject.setPid(pid);
    eObject.setRid(rid);
    bimDatabaseSession.store(eObject, pid, rid);
}

Output:
     }
-    IdEObject eObject = (IdEObject) eClass.getEPackage().getEFactoryInstance().create(eClass);
+    eObject = (IdEObject) eClass.getEPackage().getEFactoryInstance().create(eClass);
     eObject.setOid(oid);


Input:
public void setContainer(CompositeEntity container) throws IllegalActionException, NameDuplicationException {
    super.setContainer((CompositeEntity) container);
    if (container != null) {
        List<NamedObj> decoratedObjects = decoratedObjects();
        for (NamedObj decoratedObject : decoratedObjects) {
            decoratedObject.getDecoratorAttributes(this);
        }
    }
}

Output:
         for (NamedObj decoratedObject : decoratedObjects) {
-            decoratedObject.getDecoratorAttributes(this);
+            CompositeExecutionAspectAttributes decoratorAttributes = (CompositeExecutionAspectAttributes) decoratedObject.getDecoratorAttributes(this);
+            if (decoratedObject instanceof Actor) {
+                setRequestPort((Actor) decoratedObject, decoratorAttributes._requestPortName);
+            }
         }


Input:
private void parseArgs(String[] args) {
    for (int i = 0; i < args.length; i++) {
        String arg = args[i];
        if (isOption(arg)) {
            arg = stripOption(arg);
            int equalIndex = arg.indexOf('=');
            if (equalIndex != -1) {
                String key = arg.substring(0, equalIndex);
                String value = arg.substring(equalIndex + 1);
                if (value.length() > 0) {
                    map.put(key, value);
                }
            } else {
                String key = arg;
                int nextIndex = ++i;
                String value = nextIndex < args.length ? args[nextIndex] : null;
                value = value == null || isOption(value) ? null : value;
                map.put(key, value);
            }
        } else {
            orphans.add(arg);
        }
    }
}

Output:
                 String key = arg;
-                int nextIndex = ++i;
+                int nextIndex = i + 1;
                 String value = nextIndex < args.length ? args[nextIndex] : null;


Input:
public void deleteFile(File file) {
    LOG.info("String_Node_Str" + file);
    communityService.deleteFile(file);
}

Output:
     LOG.info("String_Node_Str" + file);
-    communityService.deleteFile(file);
+    try {
+        communityService.deleteFile(file);
+        try {
+            context.redirect("String_Node_Str");
+        } catch (IOException e) {
+            LOG.error("String_Node_Str");
+        }
+    } catch (ServiceException e) {
+        errorMsg = "String_Node_Str";
+        LOG.error(errorMsg);
+        setErrorMsg(errorMsg);
+    }
 }


Input:
public List<CharSequence> getSuggestions(WordComposer wordComposer, boolean includeTypedWordIfValid) {
    mExplodedAbbreviations.clear();
    mHaveCorrection = false;
    mIsFirstCharCapitalized = wordComposer.isFirstCharCapitalized();
    mIsAllUpperCase = wordComposer.isAllUpperCase();
    collectGarbage();
    Arrays.fill(mPriorities, 0);
    mOriginalWord = wordComposer.getTypedWord();
    if (mOriginalWord.length() > 0) {
        mOriginalWord = mOriginalWord.toString();
        mLowerOriginalWord = mOriginalWord.toString().toLowerCase(mLocale);
    } else {
        mLowerOriginalWord = "String_Node_Str";
    }
    if (wordComposer.length() >= mMinimumWordSizeToStartCorrecting) {
        if (mContactsDictionary != null) {
            mContactsDictionary.getWords(wordComposer, this);
        }
        if (mUserDictionary != null) {
            mUserDictionary.getWords(wordComposer, this);
        }
        if (mSuggestions.size() > 0 && isValidWord(mOriginalWord)) {
            mHaveCorrection = true;
        }
        if (mMainDict != null) {
            mMainDict.getWords(wordComposer, this);
        }
        if (mAutoTextEnabled && mAbbreviationDictionary != null) {
            mAbbreviationDictionary.getWords(wordComposer, this);
        }
        if (mSuggestions.size() > 0) {
            mHaveCorrection = true;
        }
        if (mOriginalWord != null) {
            mSuggestions.add(0, mOriginalWord.toString());
        }
        if (mExplodedAbbreviations.size() > 0) {
            for (String explodedWord : mExplodedAbbreviations) mSuggestions.add(1, explodedWord);
            mHaveCorrection = true;
        }
    }
    if (mMainDictionaryEnabled && mSuggestions.size() > 1 && mExplodedAbbreviations.size() == 0) {
        if (!haveSufficientCommonality(mLowerOriginalWord, mSuggestions.get(1))) {
            mHaveCorrection = false;
        }
    }
    if (mLowerOriginalWord.length() > 0) {
        CharSequence autoText = mAutoTextEnabled && mAutoText != null ? mAutoText.lookup(mLowerOriginalWord, 0, mLowerOriginalWord.length()) : null;
        boolean canAdd = (!TextUtils.isEmpty(autoText)) && (!TextUtils.equals(autoText, mOriginalWord));
        if (canAdd) {
            mHaveCorrection = true;
            if (mSuggestions.size() == 0) {
                mSuggestions.add(mOriginalWord);
            }
            mSuggestions.add(1, autoText);
        }
    }
    final int maxSearch = Math.min(5, mSuggestions.size());
    for (int suggestionIndex = 1; suggestionIndex < maxSearch; suggestionIndex++) {
        if (TextUtils.equals(mOriginalWord, mSuggestions.get(suggestionIndex))) {
            mSuggestions.remove(suggestionIndex);
        }
    }
    return mSuggestions;
}

Output:
     }
-    final int maxSearch = Math.min(5, mSuggestions.size());
-    for (int suggestionIndex = 1; suggestionIndex < maxSearch; suggestionIndex++) {
+    int maxSearchIndex = Math.min(5, mSuggestions.size());
+    for (int suggestionIndex = 1; suggestionIndex < maxSearchIndex; suggestionIndex++) {
         if (TextUtils.equals(mOriginalWord, mSuggestions.get(suggestionIndex))) {


Input:
protected void handleServletRequestParams() {
    if (!reqParamsProcessed && servletRequest != null && targetWindow != null && type != URLType.Portal) {
        reqParamsProcessed = true;
        try {
            servletRequest.setCharacterEncoding("String_Node_Str");
        } catch (Exception e) {
        }
        Map<String, String[]> parms = servletRequest.getParameterMap();
        if (!parms.isEmpty()) {
            String ptype = PortalURLParameter.PARAM_TYPE_RENDER;
            if (type == URLType.Action || type == URLType.AjaxAction || type == URLType.PartialAction) {
                ptype = PortalURLParameter.PARAM_TYPE_ACTION;
            } else if (type == URLType.Resource) {
                ptype = PortalURLParameter.PARAM_TYPE_RESOURCE;
            }
            for (String parm : parms.keySet()) {
                if (type == URLType.Render && targetWindow != null) {
                    int index = prpMapper.getIndex(targetWindow, parm);
                    if (index >= 0) {
                        prpMapper.setValues(index, parms.get(parm));
                        if (isDebug) {
                            StringBuilder txt = new StringBuilder("String_Node_Str");
                            txt.append(parm).append("String_Node_Str").append(Arrays.toString(parms.get(parm)));
                            txt.append("String_Node_Str" + cloneId);
                            LOG.debug(txt.toString());
                        }
                        continue;
                    }
                }
                PortalURLParameter pup = new PortalURLParameter(targetWindow, parm, parms.get(parm), ptype);
                if (parameters.contains(pup)) {
                    parameters.remove(pup);
                }
                parameters.add(pup);
                if (isDebug) {
                    StringBuilder txt = new StringBuilder("String_Node_Str");
                    txt.append(parm).append("String_Node_Str").append(Arrays.toString(parms.get(parm)));
                    txt.append(parm).append("String_Node_Str").append(ptype);
                    txt.append("String_Node_Str" + cloneId);
                    LOG.debug(txt.toString());
                }
            }
        }
    }
}

Output:
                     txt.append(parm).append("String_Node_Str").append(Arrays.toString(parms.get(parm)));
-                    txt.append(parm).append("String_Node_Str").append(ptype);
+                    txt.append("String_Node_Str").append(ptype);
                     txt.append("String_Node_Str" + cloneId);


Input:
private Message handleUnsubscribeMessage(CommandMessage message) {
    Channel channel = getChannel((String) message.getClientId());
    if (channel == null)
        return handleUnknownClientMessage(message);
    AsyncMessage reply = null;
    ServiceAdapter adapter = adapterFactory.getServiceAdapter(message);
    reply = (AcknowledgeMessage) adapter.manage(channel, message);
    postManage(channel);
    reply.setDestination(message.getDestination());
    reply.setClientId(channel.getId());
    reply.getHeaders().putAll(message.getHeaders());
    return reply;
}

Output:
     ServiceAdapter adapter = adapterFactory.getServiceAdapter(message);
-    reply = (AcknowledgeMessage) adapter.manage(channel, message);
+    if (adapter != null) {
+        reply = (AcknowledgeMessage) adapter.manage(channel, message);
+    } else {
+        log.warn("String_Node_Str" + message.getDestination());
+        reply = new AcknowledgeMessage(message);
+    }
     postManage(channel);


Input:
public void onServiceConnected(ComponentName name, IBinder binder) {
    _ownCloudSyncService = IOwnCloudSyncService.Stub.asInterface(binder);
    try {
        _ownCloudSyncService.registerCallback(callback);
        SharedPreferences mPrefs = PreferenceManager.getDefaultSharedPreferences(getActivity());
        if (mPrefs.getBoolean(SettingsActivity.CB_SYNCONSTARTUP_STRING, false))
            StartSync();
        if (getActivity() instanceof NewsReaderListActivity)
            ((NewsReaderListActivity) getActivity()).UpdateButtonSyncLayout();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Output:
         if (getActivity() instanceof NewsReaderListActivity)
-            ((NewsReaderListActivity) getActivity()).UpdateButtonSyncLayout();
+            ((NewsReaderListActivity) getActivity()).UpdateButtonLayout();
     } catch (Exception e) {


Input:
private void setDemoVersions() {
    int demoVersion = PreferenceManager.getDefaultSharedPreferences(mContext).getInt("String_Node_Str", 0);
    int versionCode = 0;
    try {
        versionCode = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0).versionCode;
    } catch (NameNotFoundException e) {
    }
    boolean newVersion = (demoVersion != versionCode);
    boolean unpack = unpackRaw(newVersion, R.raw.niv84demo, new File(mContext.getFilesDir(), "String_Node_Str"));
    if (unpack) {
        unpack = unpackRaw(newVersion, R.raw.cunpssdemo, new File(mContext.getFilesDir(), "String_Node_Str"));
    }
    if (newVersion && unpack) {
        PreferenceManager.getDefaultSharedPreferences(mContext).edit().putInt("String_Node_Str", versionCode).commit();
    }
    if (!versions.contains("String_Node_Str")) {
        versions.add("String_Node_Str");
    }
    if (!versions.contains("String_Node_Str")) {
        versions.add("String_Node_Str");
    }
}

Output:
         versionCode = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0).versionCode;
-    } catch (NameNotFoundException e) {
+    } catch (Exception e) {
     }


Input:
public void showBarFor(CPlayer player) {
    EnderBar enderBar = enderBars.get(player);
    if (!createIfDoesNotExist(player) && !enderBar.isSpawned())
        enderBar.spawn();
}

Output:
 public void showBarFor(CPlayer player) {
-    EnderBar enderBar = enderBars.get(player);
+    MobNPCEnderDragon enderBar = enderBars.get(player);
     if (!createIfDoesNotExist(player) && !enderBar.isSpawned())


Input:
void serialize(XmlSerializer serializer, String elementNamespaceUri, String elementLocalName) throws IOException {
    boolean errorOnUnknown = this.errorOnUnknown;
    if (elementLocalName == null) {
        if (errorOnUnknown) {
            throw new IllegalArgumentException("String_Node_Str");
        }
        elementLocalName = "String_Node_Str";
    }
    serializer.startTag(elementNamespaceUri, elementLocalName);
    List<String> attributeNames = this.attributeNames;
    List<Object> attributeValues = this.attributeValues;
    int num = attributeNames.size();
    for (int i = 0; i < num; i++) {
        String attributeName = attributeNames.get(i);
        int colon = attributeName.indexOf(':');
        String attributeLocalName = attributeName.substring(colon + 1);
        String attributeNamespaceUri = colon == -1 ? null : getNamespaceUriForAlias(attributeName.substring(0, colon));
        serializer.attribute(attributeNamespaceUri, attributeLocalName, toSerializedValue(attributeValues.get(i)));
    }
    Object textValue = this.textValue;
    if (textValue != null) {
        serializer.text(toSerializedValue(textValue));
    }
    List<String> subElementNames = this.subElementNames;
    List<Object> subElementValues = this.subElementValues;
    num = subElementNames.size();
    for (int i = 0; i < num; i++) {
        Object subElementValue = subElementValues.get(i);
        String subElementName = subElementNames.get(i);
        if (subElementValue instanceof List<?>) {
            for (Object subElement : (List<?>) subElementValue) {
                new ElementSerializer(subElement, errorOnUnknown).serialize(serializer, subElementName);
            }
        } else {
            new ElementSerializer(subElementValue, errorOnUnknown).serialize(serializer, subElementName);
        }
    }
    serializer.endTag(elementNamespaceUri, elementLocalName);
}

Output:
         String subElementName = subElementNames.get(i);
-        if (subElementValue instanceof List<?>) {
-            for (Object subElement : (List<?>) subElementValue) {
+        if (subElementValue instanceof Collection<?>) {
+            for (Object subElement : (Collection<?>) subElementValue) {
                 new ElementSerializer(subElement, errorOnUnknown).serialize(serializer, subElementName);


Input:
public void watch(GameEvent event, Game game) {
    if (condition == true) {
        return;
    }
    if (event.getType() == GameEvent.EventType.SPELL_CAST && game.getOpponents(controllerId).contains(event.getPlayerId())) {
        Spell spell = game.getStack().getSpell(event.getTargetId());
        if (spell.getColor(game).isRed()) {
            if (spell.getCardType().contains(CardType.INSTANT) || spell.getCardType().contains(CardType.SORCERY)) {
                condition = true;
            }
        }
    }
}

Output:
 public void watch(GameEvent event, Game game) {
-    if (condition == true) {
-        return;
-    }
-    if (event.getType() == GameEvent.EventType.SPELL_CAST && game.getOpponents(controllerId).contains(event.getPlayerId())) {
+    if (event.getType() == GameEvent.EventType.SPELL_CAST) {
         Spell spell = game.getStack().getSpell(event.getTargetId());


Input:
public static void main(String[] args) throws IOException {
    LuaState state = new LuaState();
    String script = (args.length > 0 ? args[0] : "String_Node_Str");
    System.out.println("String_Node_Str" + script + "String_Node_Str");
    state.installStandardLibs();
    LuaC.install();
    InputStream is = LuaRunner.class.getResourceAsStream(script);
    if (is == null)
        throw new java.io.FileNotFoundException("String_Node_Str" + script);
    LPrototype p = LoadState.undump(state, is, script);
    LClosure c = new LClosure(p, state._G);
    state.doCall(c, new LValue[0]);
}

Output:
 public static void main(String[] args) throws IOException {
-    LuaState state = new LuaState();
+    LuaState state = LuaState.newState();
     String script = (args.length > 0 ? args[0] : "String_Node_Str");


Input:
protected void commitToDatabaseWithChangeSet(boolean commitTransaction) throws DatabaseException, OptimisticLockException {
    try {
        startOperationProfile(SessionProfiler.UowCommit);
        boolean hasChanges = (this.unitOfWorkChangeSet != null) || hasCloneMapping() || hasDeletedObjects() || hasModifyAllQueries() || hasDeferredModifyAllQueries();
        if (hasChanges) {
            try {
                if (this.unitOfWorkChangeSet == null) {
                    this.unitOfWorkChangeSet = new UnitOfWorkChangeSet(this);
                }
                calculateChanges((IdentityHashMap) ((IdentityHashMap) getCloneMapping()).clone(), this.unitOfWorkChangeSet, true);
                getCommitManager().setIsActive(true);
            } catch (RuntimeException exception) {
                copyStatementsCountIntoProperties();
                throw exception;
            }
            hasChanges = hasModifications();
        }
        if (hasChanges) {
            commitToDatabase(commitTransaction);
        } else {
            try {
                if (wasTransactionBegunPrematurely()) {
                    if (commitTransaction) {
                        setWasTransactionBegunPrematurely(false);
                        setWasNonObjectLevelModifyQueryExecuted(false);
                        commitTransaction();
                    }
                }
                getCommitManager().setIsActive(false);
            } catch (RuntimeException exception) {
                copyStatementsCountIntoProperties();
                throw exception;
            }
        }
    } catch (RuntimeException exception) {
        handleException(exception);
    } finally {
        endOperationProfile(SessionProfiler.UowCommit);
    }
}

Output:
                 }
-                calculateChanges((IdentityHashMap) ((IdentityHashMap) getCloneMapping()).clone(), this.unitOfWorkChangeSet, true);
+                calculateChanges(cloneMap(getCloneMapping()), this.unitOfWorkChangeSet, true);
                 getCommitManager().setIsActive(true);


Input:
public List findMatches(String pattern, IProgramElement.Kind kind) {
    List matches = new ArrayList();
    IHierarchy model = AsmManager.getDefault().getHierarchy();
    if (model.equals(IHierarchy.NO_STRUCTURE)) {
        return null;
    } else {
        return findMatchesHelper((IProgramElement) model.getRoot(), pattern, kind, matches);
    }
}

Output:
     IHierarchy model = AsmManager.getDefault().getHierarchy();
-    if (model.equals(IHierarchy.NO_STRUCTURE)) {
+    if (model.getRoot().equals(IHierarchy.NO_STRUCTURE)) {
         return null;