Input:
protected void resize() {
    TableEditPart part = (TableEditPart) getSourceEditPart();
    int value = getMouseTrueValueX();
    part.getTableAdapter().transStar(RESIZE_COLUMN_TRANS_LABEL);
    if (isresizeMultipleColumn()) {
        List list = filterEditPart(part.getViewer().getSelectedEditParts());
        boolean resizeTable = false;
        int width = 0;
        for (int i = 0; i < list.size(); i++) {
            int tempValue = value;
            Object model = ((EditPart) list.get(i)).getModel();
            ColumnHandleAdapter adapter = HandleAdapterFactory.getInstance().getColumnHandleAdapter(model);
            int start = adapter.getColumnNumber();
            int end = start + 1;
            int ori = TableUtil.caleVisualWidth(part, model);
            int adjustWidth = TableUtil.caleVisualWidth(part, part.getColumn(getStart())) + value;
            if (getStart() != start) {
                tempValue = adjustWidth - ori;
            }
            if (start == part.getColumnCount()) {
                end = start;
                resizeTable = true;
            } else {
                width = width + getTrueValue(tempValue, start, end);
            }
            resizeColumn(tempValue, start, end);
        }
        if (resizeTable) {
            Dimension size = part.getTableAdapter().getSize();
            try {
                part.getTableAdapter().setSize(new Dimension(size.width + width, -1));
            } catch (SemanticException e) {
                part.getTableAdapter().rollBack();
                ExceptionHandler.handle(e);
            }
        }
    } else {
        resizeColumn(value, getStart(), getEnd());
    }
    part.getTableAdapter().transEnd();
}

Output:
     part.getTableAdapter().transStar(RESIZE_COLUMN_TRANS_LABEL);
-    if (isresizeMultipleColumn()) {
+    if (isresizeMultipleColumn() && isCtrlDown()) {
         List list = filterEditPart(part.getViewer().getSelectedEditParts());


Input:
void setReportItemReference(String referenceName) {
    try {
        if (referenceName == null) {
            itemHandle.setDataBindingReference(null);
        } else {
            itemHandle.setDataSet(null);
            itemHandle.setCube(null);
            if (!referenceName.equals(getReportItemReference())) {
                itemHandle.setDataBindingReference((ReportItemHandle) getReportDesignHandle().findElement(referenceName));
            }
        }
    } catch (SemanticException e) {
        WizardBase.showException(e.getLocalizedMessage());
    }
}

Output:
     } catch (SemanticException e) {
-        WizardBase.showException(e.getLocalizedMessage());
+        ChartWizard.showException(ChartWizard.RepDSProvider_Ref_ID, e.getLocalizedMessage());
     }


Input:
public void logOnProject(Project project, IProgressMonitor monitor) throws LoginException, PersistenceException {
    try {
        TimeMeasure.display = CommonsPlugin.isDebugMode();
        TimeMeasure.displaySteps = CommonsPlugin.isDebugMode();
        TimeMeasure.measureActive = CommonsPlugin.isDebugMode();
        TimeMeasure.begin("String_Node_Str");
        try {
            System.getProperties().put("String_Node_Str", Boolean.FALSE.toString());
            IWorkspace workspace = ResourcesPlugin.getWorkspace();
            IWorkspaceDescription description = workspace.getDescription();
            if (description.isAutoBuilding()) {
                description.setAutoBuilding(false);
                try {
                    workspace.setDescription(description);
                } catch (CoreException e) {
                }
            }
            fullLogonFinished = false;
            SubMonitor subMonitor = SubMonitor.convert(monitor, MAX_TASKS);
            SubMonitor currentMonitor = subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE);
            currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
            getRepositoryContext().setProject(project);
            currentMonitor = subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE);
            currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
            this.repositoryFactoryFromProvider.beforeLogon(project);
            TimeMeasure.step("String_Node_Str", "String_Node_Str");
            checkProjectCompatibility(project);
            if (GlobalServiceRegister.getDefault().isServiceRegistered(IMavenUIService.class)) {
                IMavenUIService mavenUIService = (IMavenUIService) GlobalServiceRegister.getDefault().getService(IMavenUIService.class);
                if (mavenUIService != null) {
                    mavenUIService.updateMavenResolver(true);
                }
            }
            currentMonitor = subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE);
            currentMonitor.beginTask("String_Node_Str", 1);
            executeMigrations(project, true, currentMonitor);
            TimeMeasure.step("String_Node_Str", "String_Node_Str");
            currentMonitor = subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE);
            currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
            this.repositoryFactoryFromProvider.logOnProject(project);
            TimeMeasure.step("String_Node_Str", "String_Node_Str");
            emptyTempFolder(project);
            currentMonitor = subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE);
            currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
            ICoreUIService coreUiService = null;
            if (GlobalServiceRegister.getDefault().isServiceRegistered(ICoreUIService.class)) {
                coreUiService = (ICoreUIService) GlobalServiceRegister.getDefault().getService(ICoreUIService.class);
            }
            if (coreUiService != null) {
                coreUiService.componentsReset();
            }
            currentMonitor = subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE);
            currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
            executeMigrations(project, false, currentMonitor);
            TimeMeasure.step("String_Node_Str", "String_Node_Str");
            if (monitor != null && monitor.isCanceled()) {
                throw new OperationCanceledException("String_Node_Str");
            }
            ICoreService coreService = getCoreService();
            if (coreService != null) {
                currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
                if (GlobalServiceRegister.getDefault().isServiceRegistered(IRunProcessService.class)) {
                    IRunProcessService runProcessService = (IRunProcessService) GlobalServiceRegister.getDefault().getService(IRunProcessService.class);
                    try {
                        runProcessService.deleteAllJobs(false);
                        runProcessService.getTalendProcessJavaProject().cleanMavenFiles(monitor);
                        TimeMeasure.step("String_Node_Str", "String_Node_Str");
                    } catch (Exception e) {
                        ExceptionHandler.process(e);
                    }
                }
                TimeMeasure.step("String_Node_Str", "String_Node_Str");
                if (workspace instanceof Workspace) {
                    ((Workspace) workspace).getFileSystemManager().getHistoryStore().clean(currentMonitor);
                }
                TimeMeasure.step("String_Node_Str", "String_Node_Str");
                currentMonitor = subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE);
                currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
                if (CommonsPlugin.isHeadless()) {
                    deleteAllRoutinesAndBeans();
                }
                try {
                    coreService.syncAllRoutines();
                    coreService.syncAllBeans();
                } catch (SystemException e1) {
                }
            }
            if (monitor != null && monitor.isCanceled()) {
                throw new OperationCanceledException("String_Node_Str");
            }
            if (coreUiService != null && PluginChecker.isRulesPluginLoaded()) {
                coreUiService.syncAllRules();
            }
            if (monitor != null && monitor.isCanceled()) {
                throw new OperationCanceledException("String_Node_Str");
            }
            TimeMeasure.step("String_Node_Str", "String_Node_Str");
            if (coreUiService != null) {
                coreService.syncLog4jSettings();
            }
            TimeMeasure.step("String_Node_Str", "String_Node_Str");
            if (CommonUIPlugin.isFullyHeadless()) {
                currentMonitor = subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE);
                currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
                coreService.syncLibraries(currentMonitor);
                TimeMeasure.step("String_Node_Str", "String_Node_Str");
                if (monitor != null && monitor.isCanceled()) {
                    throw new OperationCanceledException("String_Node_Str");
                }
                coreService.createStatsLogAndImplicitParamter(project);
                if (monitor != null && monitor.isCanceled()) {
                    throw new OperationCanceledException("String_Node_Str");
                }
                coreService.synchronizeMapptingXML();
                if (monitor != null && monitor.isCanceled()) {
                    throw new OperationCanceledException("String_Node_Str");
                }
            }
            if (GlobalServiceRegister.getDefault().isServiceRegistered(ITDQRepositoryService.class)) {
                ITDQRepositoryService tdqRepositoryService = (ITDQRepositoryService) GlobalServiceRegister.getDefault().getService(ITDQRepositoryService.class);
                if (tdqRepositoryService != null) {
                    tdqRepositoryService.initProxyRepository();
                }
            }
            fullLogonFinished = true;
            this.repositoryFactoryFromProvider.afterLogon();
        } finally {
            TimeMeasure.end("String_Node_Str");
            TimeMeasure.display = false;
            TimeMeasure.displaySteps = false;
            TimeMeasure.measureActive = false;
        }
        String[] str = new String[] { getRepositoryContext().getUser() + "String_Node_Str", projectManager.getCurrentProject() + "String_Node_Str" };
        log.info(Messages.getString("String_Node_Str", str));
    } catch (LoginException e) {
        logOffProject();
        throw e;
    } catch (PersistenceException e) {
        logOffProject();
        throw e;
    } catch (RuntimeException e) {
        logOffProject();
        throw e;
    }
}

Output:
                 currentMonitor.beginTask(Messages.getString("String_Node_Str"), 1);
-                if (GlobalServiceRegister.getDefault().isServiceRegistered(IRunProcessService.class)) {
-                    IRunProcessService runProcessService = (IRunProcessService) GlobalServiceRegister.getDefault().getService(IRunProcessService.class);
-                    try {
-                        runProcessService.deleteAllJobs(false);
-                        runProcessService.getTalendProcessJavaProject().cleanMavenFiles(monitor);
-                        TimeMeasure.step("String_Node_Str", "String_Node_Str");
-                    } catch (Exception e) {
-                        ExceptionHandler.process(e);
-                    }
-                }
+                coreService.deleteAllJobs(false);
                 TimeMeasure.step("String_Node_Str", "String_Node_Str");


Input:
public void testZhaoFeatureBuilding() throws ParseException, IOException {
    CorpusStatisticsPrm csPrm = new CorpusStatisticsPrm();
    csPrm.useGoldSyntax = true;
    CorpusStatistics cs = new CorpusStatistics(csPrm);
    SentFeatureExtractorPrm fePrm = new SentFeatureExtractorPrm();
    fePrm.withSupervision = true;
    fePrm.useNaradFeats = false;
    fePrm.useLexicalDepPathFeats = false;
    fePrm.useSimpleFeats = false;
    fePrm.useZhaoFeats = true;
    File train = new File("String_Node_Str");
    CoNLL09FileReader reader = new CoNLL09FileReader(train);
    Timer timer = new Timer();
    timer.start();
    for (int n = 0; n < 49; n++) {
        CoNLL09Sentence sent = reader.next();
        SimpleAnnoSentence simpleSent = sent.toSimpleAnnoSentence(csPrm.useGoldSyntax);
        log.info("String_Node_Str");
        SentFeatureExtractor fe = new SentFeatureExtractor(fePrm, simpleSent, cs);
        log.info("String_Node_Str");
        for (int i = 0; i < sent.size(); i++) {
            for (int j = 0; j < sent.size(); j++) {
                fe.createFeatureSet(i, j);
            }
        }
        timer.split();
        log.info("String_Node_Str");
    }
    timer.stop();
    log.info("String_Node_Str" + timer.avgMs());
}

Output:
         log.info("String_Node_Str");
-        for (int i = 0; i < sent.size(); i++) {
+        for (int i = -1; i < sent.size(); i++) {
             for (int j = 0; j < sent.size(); j++) {


Input:
private void onSelectedResource(int index) {
    updateCurrentResource();
    currentResourceIndex = index;
    mCurrentConnectionTypeIndex = 0;
    updateResourceTable();
}

Output:
 private void onSelectedResource(int index) {
-    updateCurrentResource();
+    if (index != -1) {
+        updateCurrentResource();
+    }
     currentResourceIndex = index;


Input:
private TypeCheckElimination[] getTable() {
    if (selectedPackage != null)
        new ASTReader(selectedPackage);
    else
        new ASTReader(selectedProject);
    SystemObject systemObject = ASTReader.getSystemObject();
    typeCheckEliminationResults = systemObject.generateTypeCheckEliminations();
    List<TypeCheckElimination> typeCheckEliminations = typeCheckEliminationResults.getTypeCheckEliminations();
    TypeCheckElimination[] table = new TypeCheckElimination[typeCheckEliminations.size()];
    int i = 0;
    for (TypeCheckElimination typeCheckElimination : typeCheckEliminations) {
        table[i] = typeCheckElimination;
        i++;
    }
    return table;
}

Output:
         new ASTReader(selectedProject);
-    SystemObject systemObject = ASTReader.getSystemObject();
-    typeCheckEliminationResults = systemObject.generateTypeCheckEliminations();
+    final SystemObject systemObject = ASTReader.getSystemObject();
+    IWorkbenchWindow window = getSite().getWorkbenchWindow();
+    try {
+        window.getWorkbench().getProgressService().run(true, true, new IRunnableWithProgress() {
+            public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
+                typeCheckEliminationResults = systemObject.generateTypeCheckEliminations(monitor);
+            }
+        });
+    } catch (InvocationTargetException e) {
+        e.printStackTrace();
+    } catch (InterruptedException e) {
+        e.printStackTrace();
+    }
     List<TypeCheckElimination> typeCheckEliminations = typeCheckEliminationResults.getTypeCheckEliminations();


Input:
public ListBidcosInterfacesParser parse(Object[] message) throws IOException {
    if (message != null && message.length > 0) {
        message = (Object[]) message[0];
        for (int i = 0; i < message.length; i++) {
            Map<String, ?> mapMessage = (Map<String, ?>) message[i];
            boolean isDefault = toBoolean(mapMessage.get("String_Node_Str"));
            if (isDefault) {
                type = toString(mapMessage.get("String_Node_Str"));
                firmware = toString(mapMessage.get("String_Node_Str"));
                gatewayAddress = toString(mapMessage.get("String_Node_Str"));
            }
        }
    }
    return this;
}

Output:
                 firmware = toString(mapMessage.get("String_Node_Str"));
-                gatewayAddress = toString(mapMessage.get("String_Node_Str"));
+                gatewayAddress = getSanitizedAddress(mapMessage.get("String_Node_Str"));
             }


Input:
private long toLowerBitsWritePosition(long index) {
    return index >> cycleShift;
}

Output:
 private long toLowerBitsWritePosition(long index) {
-    return index >> cycleShift;
+    return index >>> cycleShift;
 }


Input:
public void checkTypes(MarkerList markers, IContext context) {
    if (this.instance != null) {
        this.instance.checkTypes(markers, context);
    }
    if (this.method != null) {
        this.method.checkArguments(markers, this.position, context, this.instance, this.arguments, this.getGenericData());
    }
    this.arguments.checkTypes(markers, context);
}

Output:
     if (this.method != null) {
-        this.method.checkArguments(markers, this.position, context, this.instance, this.arguments, this.getGenericData());
+        this.instance = this.method.checkArguments(markers, this.position, context, this.instance, this.arguments, this.getGenericData());
     }


Input:
public String getJvmOptions() {
    return jvmOptions;
}

Output:
 public String getJvmOptions() {
-    return jvmOptions;
+    return jvmOptions == null ? "String_Node_Str" : jvmOptions;
 }


Input:
private void fullyPopulateCaches(final int userHandle) {
    DatabaseHelper dbHelper = mOpenHelpers.get(userHandle);
    if (userHandle == UserHandle.USER_OWNER) {
        fullyPopulateCache(dbHelper, TABLE_GLOBAL, sGlobalCache);
    }
    fullyPopulateCache(dbHelper, TABLE_SECURE, sSecureCaches.get(userHandle));
    fullyPopulateCache(dbHelper, TABLE_SYSTEM, sSystemCaches.get(userHandle));
}

Output:
 private void fullyPopulateCaches(final int userHandle) {
-    DatabaseHelper dbHelper = mOpenHelpers.get(userHandle);
+    DatabaseHelper dbHelper;
+    synchronized (this) {
+        dbHelper = mOpenHelpers.get(userHandle);
+    }
+    if (dbHelper == null) {
+        return;
+    }
     if (userHandle == UserHandle.USER_OWNER) {


Input:
public boolean canBlockSkip(final IFilter filter) {
    switch(filter.getFilterType()) {
        case NUMBER:
            NumberFilter numberFilter = (NumberFilter) filter;
            Float setNumber;
            try {
                setNumber = Float.valueOf(numberFilter.getNumberObject().getFloat());
            } catch (NumberFormatException | IOException e) {
                return false;
            }
            switch(numberFilter.getNumberFilterType()) {
                case EQUAL:
                    if (0 < min.compareTo(setNumber) || max.compareTo(setNumber) < 0) {
                        return true;
                    }
                    return false;
                case LT:
                    if (0 <= min.compareTo(setNumber)) {
                        return true;
                    }
                    return false;
                case LE:
                    if (0 < min.compareTo(setNumber)) {
                        return true;
                    }
                    return false;
                case GT:
                    if (max.compareTo(setNumber) <= 0) {
                        return true;
                    }
                    return false;
                case GE:
                    if (max.compareTo(setNumber) < 0) {
                        return true;
                    }
                    return false;
                default:
                    return false;
            }
        case NUMBER_RANGE:
            NumberRangeFilter numberRangeFilter = (NumberRangeFilter) filter;
            Float setMin;
            Float setMax;
            try {
                setMin = Float.valueOf(numberRangeFilter.getMinObject().getFloat());
                setMax = Float.valueOf(numberRangeFilter.getMaxObject().getFloat());
            } catch (NumberFormatException | IOException e) {
                return false;
            }
            boolean minHasEquals = numberRangeFilter.isMinHasEquals();
            boolean maxHasEquals = numberRangeFilter.isMaxHasEquals();
            boolean invert = numberRangeFilter.isInvert();
            if (minHasEquals && maxHasEquals) {
                if ((min.compareTo(setMin) < 0 && 0 < max.compareTo(setMax)) != invert) {
                    return true;
                }
                return false;
            } else if (minHasEquals) {
                if ((min.compareTo(setMin) < 0 && 0 <= max.compareTo(setMax)) != invert) {
                    return true;
                }
                return false;
            } else if (maxHasEquals) {
                if ((min.compareTo(setMin) <= 0 && 0 < max.compareTo(setMax)) != invert) {
                    return true;
                }
                return false;
            } else {
                if ((min.compareTo(setMin) <= 0 && 0 <= max.compareTo(setMax)) != invert) {
                    return true;
                }
                return false;
            }
        default:
            return false;
    }
}

Output:
             if (minHasEquals && maxHasEquals) {
-                if ((min.compareTo(setMin) < 0 && 0 < max.compareTo(setMax)) != invert) {
+                if ((0 < min.compareTo(setMax) || max.compareTo(setMin) < 0) != invert) {
                     return true;


Input:
public static Properties getPropertiesFromClasspath(String pFileName) {
    Properties props = new Properties();
    try {
        props.load(ClassLoader.getSystemResourceAsStream(pFileName));
    } catch (IOException e) {
        logger.error("String_Node_Str", e);
    }
    return props;
}

Output:
     try {
-        props.load(ClassLoader.getSystemResourceAsStream(pFileName));
+        InputStream is = ClassLoader.getSystemResourceAsStream(fileName);
+        if (is == null) {
+            is = Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);
+            logger.debug("String_Node_Str");
+        }
+        props.load(is);
     } catch (IOException e) {


Input:
public void test() throws AMQException, JMSException, URISyntaxException {
    System.setProperty("String_Node_Str", "String_Node_Str");
    System.setProperty("String_Node_Str", "String_Node_Str");
    System.setProperty("String_Node_Str", "String_Node_Str");
    System.setProperty("String_Node_Str", "String_Node_Str");
    String connstr = "String_Node_Str";
    Connection conn = new AMQConnection(connstr);
    conn.start();
    Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Destination dest = new AMQAnyDestination("String_Node_Str");
    MessageConsumer consumer = sess.createConsumer(dest);
    Message msg;
    while ((msg = consumer.receive(-1)) != null) {
        System.out.println("String_Node_Str");
        System.out.println(msg);
        System.out.println("String_Node_Str");
    }
    consumer.close();
    sess.close();
    conn.close();
    System.out.println("String_Node_Str");
}

Output:
     System.setProperty("String_Node_Str", "String_Node_Str");
-    String connstr = "String_Node_Str";
+    String connstr = "String_Node_Str" + "String_Node_Str";
     Connection conn = new AMQConnection(connstr);


Input:
public boolean incrementToken() throws IOException {
    clearAttributes();
    if (first) {
        String[][] wordsAndPOS = walkTokens();
        String[] words = wordsAndPOS[0];
        if (words.length == 0) {
            return false;
        }
        String[] pos = wordsAndPOS[1];
        Span[] chunks = regexChunker.find(pos);
        chunks = prune(chunks, words);
        for (Span sp : chunks) {
            chunkSpans.put(sp.getStart(), sp.getEnd());
            chunkTypes.put(sp.getStart(), sp.getType());
        }
        first = false;
        tokenIdx = 0;
    }
    if (tokenIdx == tokenAttrs.size()) {
        resetParams();
        return false;
    }
    if (chunkStart != -1 && tokenIdx == chunkEnd) {
        boolean added = addMWE();
        return true;
    }
    if (chunkSpans.containsKey(tokenIdx)) {
        chunkStart = tokenIdx;
        chunkEnd = chunkSpans.get(tokenIdx);
        tokenIdx++;
        return true;
    } else {
        tokenIdx++;
        return true;
    }
}

Output:
         for (Span sp : chunks) {
-            chunkSpans.put(sp.getStart(), sp.getEnd());
+            List<Integer> ends = chunkSpans.get(sp.getStart());
+            if (ends == null)
+                ends = new ArrayList<>();
+            ends.add(sp.getEnd());
+            chunkSpans.put(sp.getStart(), ends);
             chunkTypes.put(sp.getStart(), sp.getType());


Input:
private String findWord(ITextViewer viewer, int offset) throws BadLocationException {
    char ch = viewer.getDocument().getChar(offset);
    int startOffset = offset;
    if (isClosingQuoteChar(ch)) {
        startOffset--;
        char quoteChar = ch;
        if (quoteChar != '\'' || quoteChar != '"') {
            quoteChar = getOpeningQuoteChar();
        }
        for (; startOffset > viewer.getTopIndexStartOffset(); startOffset--) {
            ch = viewer.getDocument().getChar(startOffset);
            if (ch == quoteChar) {
                break;
            }
        }
    } else {
        while (startOffset > viewer.getTopIndexStartOffset() && Character.isLetterOrDigit(viewer.getDocument().getChar(startOffset))) {
            startOffset--;
        }
        startOffset++;
    }
    return viewer.getDocument().get(startOffset, offset - startOffset + 1);
}

Output:
     } else {
-        while (startOffset > viewer.getTopIndexStartOffset() && Character.isLetterOrDigit(viewer.getDocument().getChar(startOffset))) {
+        while (startOffset > viewer.getTopIndexStartOffset() && viewer.getDocument().getChar(startOffset) != '.' && viewer.getDocument().getChar(startOffset) != ' ') {
             startOffset--;


Input:
public void proceedSIPInfo(JingleIQ iq, CallSession session, SipChannel channel) {
    if (session != null) {
        callKiller.scheduleKill(session, 2);
    } else {
        callKiller.scheduleKill(iq, 2);
    }
}

Output:
     if (session != null) {
-        callKiller.scheduleKill(session, 2);
+        callKiller.scheduleKill(session, sleepTime);
     } else {


Input:
public void setTextSizeFloat(float textSize) {
    mMessageTextView.setTextSize(TypedValue.COMPLEX_UNIT_SP, textSize);
}

Output:
 public void setTextSizeFloat(float textSize) {
-    mMessageTextView.setTextSize(TypedValue.COMPLEX_UNIT_SP, textSize);
+    mMessageTextView.setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize);
 }


Input:
private void createDispoItems(DispoProgram program, String setId, List<DispoItem> dispoItems) {
    DispoSet parentSet = getQuery().findDispoSetsById(program, setId);
    if (parentSet != null) {
        ArtifactReadable author = getQuery().findUser();
        getWriter().createDispoItems(author, program, parentSet, dispoItems, "String_Node_Str");
    }
}

Output:
         ArtifactReadable author = getQuery().findUser();
-        getWriter().createDispoItems(author, program, parentSet, dispoItems, "String_Node_Str");
+        getWriter().createDispoItems(author, program, parentSet, dispoItems);
     }


Input:
public static void storeOrderedEnabledQuickKeys(Context applicationContext, List<QuickTextKey> orderedKeys) {
    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(applicationContext);
    String settingKey = applicationContext.getString(R.string.settings_key_ordered_active_quick_text_keys);
    Set<String> storedKeys = new HashSet<>();
    List<String> quickKeyIdOrder = new ArrayList<>(orderedKeys.size());
    for (QuickTextKey key : orderedKeys) {
        final String id = key.getId();
        if (!storedKeys.contains(id))
            quickKeyIdOrder.add(id);
        storedKeys.add(id);
    }
    SharedPreferences.Editor editor = sharedPreferences.edit();
    editor.putString(settingKey, TextUtils.join("String_Node_Str", quickKeyIdOrder)).commit();
}

Output:
     SharedPreferences.Editor editor = sharedPreferences.edit();
-    editor.putString(settingKey, TextUtils.join("String_Node_Str", quickKeyIdOrder)).commit();
+    editor.putString(settingKey, TextUtils.join("String_Node_Str", quickKeyIdOrder));
+    SharedPreferencesCompat.EditorCompat.getInstance().apply(editor);
 }


Input:
private void postProcessForeachLoop(Continuation c) {
    AbstractForeachLoop loop = (AbstractForeachLoop) c;
    Counters<Var> readIncrs = new Counters<Var>();
    Counters<Var> writeIncrs = new Counters<Var>();
    if (loop.isAsync()) {
        for (PassedVar v : loop.getPassedVars()) {
            if (!v.writeOnly && RefCounting.hasReadRefCount(v.var)) {
                readIncrs.increment(v.var);
            }
        }
        for (Var v : loop.getKeepOpenVars()) {
            if (RefCounting.hasWriteRefCount(v)) {
                writeIncrs.increment(v);
            }
        }
    }
    Block loopBody = loop.getLoopBody();
    ListIterator<Statement> it = loopBody.statementIterator();
    while (it.hasNext()) {
        Statement stmt = it.next();
        if (stmt.type() != StatementType.INSTRUCTION || !RefCountOp.isIncrement(stmt.instruction().op)) {
            break;
        }
        Instruction inst = stmt.instruction();
        Arg amount = RefCountOp.getRCAmount(inst);
        Var var = RefCountOp.getRCTarget(inst);
        RefCountType rcType = RefCountOp.getRCType(inst.op);
        if (amount.isIntVal() && RCUtil.definedOutsideCont(loop, loopBody, var)) {
            if (rcType == RefCountType.READERS) {
                readIncrs.add(var, amount.getIntLit());
            } else {
                assert (rcType == RefCountType.WRITERS);
                writeIncrs.add(var, amount.getIntLit());
            }
            it.remove();
        }
    }
    for (Entry<Var, Long> read : readIncrs.entries()) {
        loop.addStartIncrement(new RefCount(read.getKey(), RefCountType.READERS, Arg.createIntLit(read.getValue())));
    }
    for (Entry<Var, Long> write : writeIncrs.entries()) {
        loop.addStartIncrement(new RefCount(write.getKey(), RefCountType.WRITERS, Arg.createIntLit(write.getValue())));
    }
}

Output:
     if (loop.isAsync()) {
-        for (PassedVar v : loop.getPassedVars()) {
+        for (PassedVar v : loop.getAllPassedVars()) {
             if (!v.writeOnly && RefCounting.hasReadRefCount(v.var)) {


Input:
public Object intercept(MethodInvocationContext<Object, Object> context) {
    Client clientAnnotation = context.getAnnotation(Client.class);
    if (clientAnnotation == null) {
        throw new IllegalStateException("String_Node_Str" + context);
    }
    ClientRegistration reg = getClient(clientAnnotation);
    Optional<Class<? extends Annotation>> httpMethodMapping = context.getAnnotationTypeByStereotype(HttpMethodMapping.class);
    if (httpMethodMapping.isPresent()) {
        String uri = context.getValue(HttpMethodMapping.class, String.class).orElse("String_Node_Str");
        Class<? extends Annotation> annotationType = httpMethodMapping.get();
        HttpMethod httpMethod = HttpMethod.valueOf(annotationType.getSimpleName().toUpperCase());
        ReturnType returnType = context.getReturnType();
        Class<?> javaReturnType = returnType.getType();
        String contextPath = reg.contextPath;
        UriMatchTemplate uriTemplate = UriMatchTemplate.of(contextPath != null ? contextPath : "String_Node_Str");
        if (!(uri.length() == 1 && uri.charAt(0) == '/')) {
            uriTemplate = uriTemplate.nest(uri);
        }
        Map<String, Object> paramMap = context.getParameterValueMap();
        List<String> uriVariables = uriTemplate.getVariables();
        boolean variableSatisfied = uriVariables.isEmpty() || uriVariables.containsAll(paramMap.keySet());
        MutableHttpRequest<Object> request;
        Object body = null;
        Map<String, MutableArgumentValue<?>> parameters = context.getParameters();
        Argument[] arguments = context.getArguments();
        Map<String, String> headers = new LinkedHashMap<>(3);
        List<Argument> bodyArguments = new ArrayList<>();
        for (Argument argument : arguments) {
            String argumentName = argument.getName();
            if (argument.isAnnotationPresent(Body.class)) {
                body = parameters.get(argumentName).getValue();
                break;
            } else if (argument.isAnnotationPresent(Header.class)) {
                String headerName = argument.getAnnotation(Header.class).value();
                if (StringUtils.isEmpty(headerName)) {
                    headerName = NameUtils.hyphenate(argumentName);
                }
                MutableArgumentValue<?> value = parameters.get(argumentName);
                String finalHeaderName = headerName;
                ConversionService.SHARED.convert(value.getValue(), String.class).ifPresent(o -> headers.put(finalHeaderName, o));
            } else if (!uriVariables.contains(argumentName)) {
                bodyArguments.add(argument);
            }
        }
        if (HttpMethod.permitsRequestBody(httpMethod)) {
            if (body == null && !bodyArguments.isEmpty()) {
                Map<String, Object> bodyMap = new LinkedHashMap<>();
                for (Argument bodyArgument : bodyArguments) {
                    String argumentName = bodyArgument.getName();
                    MutableArgumentValue<?> value = parameters.get(argumentName);
                    bodyMap.put(argumentName, value.getValue());
                }
                body = bodyMap;
            }
            if (body != null) {
                if (!variableSatisfied) {
                    if (body instanceof Map) {
                        paramMap.putAll((Map) body);
                        uri = uriTemplate.expand(paramMap);
                        request = HttpRequest.create(httpMethod, uri);
                    } else {
                        paramMap.putAll(BeanMap.of(body));
                        uri = uriTemplate.expand(paramMap);
                        request = HttpRequest.create(httpMethod, uri);
                    }
                } else {
                    uri = uriTemplate.expand(paramMap);
                    request = HttpRequest.create(httpMethod, uri);
                }
                request.body(body);
            } else {
                uri = uriTemplate.expand(paramMap);
                request = HttpRequest.create(httpMethod, uri);
            }
        } else {
            uri = uriTemplate.expand(paramMap);
            request = HttpRequest.create(httpMethod, uri);
        }
        if (!headers.isEmpty()) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                request.header(entry.getKey(), entry.getValue());
            }
        }
        HttpClient httpClient = reg.httpClient;
        boolean isFuture = CompletableFuture.class.isAssignableFrom(javaReturnType);
        if (Publishers.isPublisher(javaReturnType) || isFuture) {
            Argument<?> publisherArgument = returnType.asArgument().getFirstTypeVariable().orElse(Argument.OBJECT_ARGUMENT);
            Class<?> argumentType = publisherArgument.getType();
            Publisher<?> publisher;
            if (HttpResponse.class.isAssignableFrom(argumentType)) {
                publisher = httpClient.exchange(request, returnType.asArgument().getFirstTypeVariable().orElse(Argument.OBJECT_ARGUMENT));
            } else {
                publisher = httpClient.retrieve(request, publisherArgument);
            }
            if (isFuture) {
                CompletableFuture<Object> future = new CompletableFuture<>();
                publisher.subscribe(new CompletionAwareSubscriber<Object>() {
                    AtomicReference<Object> reference = new AtomicReference<>();
                    protected void doOnSubscribe(Subscription subscription) {
                        subscription.request(1);
                    }
                    protected void doOnNext(Object message) {
                        reference.set(message);
                    }
                    protected void doOnError(Throwable t) {
                        if (t instanceof HttpClientResponseException) {
                            HttpClientResponseException e = (HttpClientResponseException) t;
                            if (e.getStatus() == HttpStatus.NOT_FOUND) {
                                future.complete(null);
                            } else {
                                future.completeExceptionally(t);
                            }
                        }
                        future.completeExceptionally(t);
                    }
                    protected void doOnComplete() {
                        future.complete(reference.get());
                    }
                });
                return future;
            } else {
                Object finalPublisher = ConversionService.SHARED.convert(publisher, javaReturnType).orElseThrow(() -> new HttpClientException("String_Node_Str" + javaReturnType));
                for (ClientPublisherResultTransformer transformer : transformers) {
                    finalPublisher = transformer.transform(finalPublisher);
                }
                return finalPublisher;
            }
        } else {
            BlockingHttpClient blockingHttpClient = httpClient.toBlocking();
            if (HttpResponse.class.isAssignableFrom(javaReturnType)) {
                return blockingHttpClient.exchange(request, returnType.asArgument().getFirstTypeVariable().orElse(Argument.OBJECT_ARGUMENT));
            } else if (void.class == javaReturnType) {
                blockingHttpClient.exchange(request);
                return null;
            } else {
                try {
                    return blockingHttpClient.retrieve(request, returnType.asArgument());
                } catch (HttpClientResponseException e) {
                    if (e.getStatus() == HttpStatus.NOT_FOUND) {
                        if (javaReturnType == Optional.class) {
                            return Optional.empty();
                        }
                        return null;
                    }
                    throw e;
                }
            }
        }
    }
    throw new UnsupportedOperationException("String_Node_Str");
}

Output:
     }
-    throw new UnsupportedOperationException("String_Node_Str");
+    throw new UnsupportedOperationException("String_Node_Str" + context + "String_Node_Str");
 }


Input:
public byte[] getRawData() {
    return getContent().getBytes();
}

Output:
 public byte[] getRawData() {
-    return getContent().getBytes();
+    return rawContent;
 }


Input:
public static void main(String[] args) throws Exception {
    String fileName = args[0];
    int windowSize = Integer.parseInt(args[1]);
    int localIter = Integer.parseInt(args[2]);
    long timeLimit = Long.parseLong(args[3]);
    int seed = Integer.parseInt(args[4]);
    int dataSetSize = Integer.parseInt(args[5]);
    double learningRate = Double.parseDouble(args[6]);
    final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
    DataFlink<DataInstance> dataFlink = DataFlinkLoader.loadDataFromFolder(env, fileName, true);
    DAG hiddenNB = getDAGstructure(dataFlink.getAttributes());
    long start = System.nanoTime();
    StochasticVI stochasticVI = new StochasticVI();
    stochasticVI.setLocalThreshold(0.1);
    stochasticVI.setMaximumLocalIterations(localIter);
    stochasticVI.setSeed(seed);
    stochasticVI.setBatchSize(windowSize);
    stochasticVI.setLearningFactor(learningRate);
    stochasticVI.setDataSetSize(dataSetSize);
    stochasticVI.setTimiLimit(timeLimit);
    stochasticVI.setDAG(hiddenNB);
    stochasticVI.setDataFlink(dataFlink);
    stochasticVI.runLearning();
    BayesianNetwork LearnedBnet = stochasticVI.getLearntBayesianNetwork();
    System.out.println(LearnedBnet.toString());
    long duration = (System.nanoTime() - start) / 1;
    double seconds = duration / 1000000000.0;
    logger.info("String_Node_Str", seconds);
}

Output:
     final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-    DataFlink<DataInstance> dataFlink = DataFlinkLoader.loadDataFromFolder(env, fileName, true);
-    DAG hiddenNB = getDAGstructure(dataFlink.getAttributes());
+    DataFlink<DataInstance> dataFlink = DataFlinkLoader.loadDataFromFolder(env, fileName, false);
+    DAG hiddenNB = getIDALocalGlobalDAG(dataFlink.getAttributes());
     long start = System.nanoTime();


Input:
private static Participation parseParticipation(NestedDocument<QName> participation) {
    URI persistentIdentity = null;
    String displayId = null;
    String version = null;
    Set<URI> role = new HashSet<>();
    URI participant = null;
    URI wasDerivedFrom = null;
    List<Annotation> annotations = new ArrayList<>();
    for (NamedProperty<QName> p : participation.getProperties()) {
        if (p.getName().equals(Sbol2Terms.Identified.persistentIdentity)) {
            persistentIdentity = URI.create(((Literal<QName>) p.getValue()).getValue().toString());
        } else if (p.getName().equals(Sbol2Terms.Identified.version)) {
            version = ((Literal<QName>) p.getValue()).getValue().toString();
        } else if (p.getName().equals(Sbol2Terms.Documented.displayId)) {
            displayId = ((Literal<QName>) p.getValue()).getValue().toString();
        } else if (p.getName().equals(Sbol2Terms.Participation.role)) {
            role.add(URI.create(((Literal<QName>) p.getValue()).getValue().toString()));
        } else if (p.getName().equals(Sbol2Terms.Participation.hasParticipant)) {
            participant = URI.create(((Literal<QName>) p.getValue()).getValue().toString());
        } else if (p.getName().equals(ProvTerms.Prov.wasDerivedFrom)) {
            wasDerivedFrom = URI.create(((Literal<QName>) p.getValue()).getValue().toString());
        } else {
            annotations.add(new Annotation(p));
        }
    }
    Participation p = new Participation(participation.getIdentity(), participant);
    if (role != null)
        p.setRoles(role);
    if (displayId != null)
        p.setDisplayId(displayId);
    if (persistentIdentity != null)
        p.setPersistentIdentity(persistentIdentity);
    if (version != null)
        p.setVersion(version);
    if (wasDerivedFrom != null)
        p.setWasDerivedFrom(wasDerivedFrom);
    if (!annotations.isEmpty())
        p.setAnnotations(annotations);
    return p;
}

Output:
     String version = null;
-    Set<URI> role = new HashSet<>();
+    Set<URI> roles = new HashSet<>();
     URI participant = null;


Input:
private void checkRepository(final Node node, Item item, CommandStack stack) {
    final String updataComponentParamName = EParameterName.UPDATE_COMPONENTS.getName();
    final List<IElementParameter> repositoryParam = new ArrayList<IElementParameter>();
    for (IElementParameter param : node.getElementParameters()) {
        if (param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE)) {
            String value = (String) param.getChildParameters().get(EParameterName.SCHEMA_TYPE.getName()).getValue();
            if (value.equals(EmfComponent.REPOSITORY)) {
                IElementParameter schema = param.getChildParameters().get(EParameterName.REPOSITORY_SCHEMA_TYPE.getName());
                if (schema != null && schema.getValue() != null) {
                    String[] names = ((String) schema.getValue()).split("String_Node_Str");
                    if (names.length > 0) {
                        if (names[0].equals(item.getProperty().getId())) {
                            repositoryParam.add(schema);
                        }
                    }
                }
            }
        } else if (param.getFieldType().equals(EParameterFieldType.PROPERTY_TYPE)) {
            Object value = param.getChildParameters().get(EParameterName.PROPERTY_TYPE.getName()).getValue();
            if (value.equals(EmfComponent.REPOSITORY)) {
                IElementParameter property = param.getChildParameters().get(EParameterName.REPOSITORY_PROPERTY_TYPE.getName());
                if (property != null && property.getValue() != null) {
                    if (property.getValue().equals(item.getProperty().getId())) {
                        repositoryParam.add(property);
                    }
                }
            }
        }
    }
    if (repositoryParam.isEmpty()) {
        return;
    }
    stack.execute(new Command() {
        public void execute() {
            node.setPropertyValue(updataComponentParamName, new Boolean(true));
            for (IElementParameter param : repositoryParam) {
                param.setListItemsDisplayName(new String[0]);
                param.setListItemsValue(new String[0]);
            }
        }
    });
}

Output:
     for (IElementParameter param : node.getElementParameters()) {
-        if (param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE)) {
+        if (param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE) || param.getFieldType().equals(EParameterFieldType.SCHEMA_REFERENCE)) {
             String value = (String) param.getChildParameters().get(EParameterName.SCHEMA_TYPE.getName()).getValue();


Input:
public void previewResultsTest() throws Exception {
    Id.DatasetInstance myTable2 = Id.DatasetInstance.from(NAMESPACE_ID, "String_Node_Str");
    Id.DatasetInstance myTable3 = Id.DatasetInstance.from(NAMESPACE_ID, "String_Node_Str");
    Id.DatasetInstance myTable4 = Id.DatasetInstance.from(NAMESPACE_ID, "String_Node_Str");
    Id.DatasetInstance myTable5 = Id.DatasetInstance.from(NAMESPACE_ID, "String_Node_Str");
    Id.DatasetInstance myTable6 = Id.DatasetInstance.from(NAMESPACE_ID, "String_Node_Str");
    datasetFramework.addInstance("String_Node_Str", myTable2, DatasetProperties.EMPTY);
    datasetFramework.addInstance("String_Node_Str", myTable3, DatasetProperties.EMPTY);
    datasetFramework.addInstance("String_Node_Str", myTable4, DatasetProperties.EMPTY);
    datasetFramework.addInstance("String_Node_Str", myTable5, DatasetProperties.EMPTY);
    datasetFramework.addInstance("String_Node_Str", myTable6, DatasetProperties.EMPTY);
    try {
        QueryHandle handle = exploreService.execute(NAMESPACE_ID, "String_Node_Str");
        QueryStatus status = waitForCompletionStatus(handle, 200, TimeUnit.MILLISECONDS, 50);
        Assert.assertEquals(QueryStatus.OpStatus.FINISHED, status.getStatus());
        List<QueryResult> firstPreview = exploreService.previewResults(handle);
        Assert.assertEquals(ImmutableList.of(new QueryResult(ImmutableList.<Object>of(MY_TABLE_NAME)), new QueryResult(ImmutableList.<Object>of("String_Node_Str")), new QueryResult(ImmutableList.<Object>of("String_Node_Str")), new QueryResult(ImmutableList.<Object>of("String_Node_Str")), new QueryResult(ImmutableList.<Object>of("String_Node_Str"))), firstPreview);
        List<QueryResult> endResults = exploreService.nextResults(handle, 100);
        Assert.assertEquals(ImmutableList.of(new QueryResult(ImmutableList.<Object>of("String_Node_Str"))), endResults);
        List<QueryResult> secondPreview = exploreService.previewResults(handle);
        Assert.assertEquals(firstPreview, secondPreview);
        Assert.assertEquals(ImmutableList.of(), exploreService.nextResults(handle, 100));
        try {
            exploreService.previewResults(handle);
            Assert.fail("String_Node_Str");
        } catch (HandleNotFoundException e) {
            Assert.assertTrue(e.isInactive());
        }
    } finally {
        datasetFramework.deleteInstance(myTable2);
        datasetFramework.deleteInstance(myTable3);
        datasetFramework.deleteInstance(myTable4);
        datasetFramework.deleteInstance(myTable5);
        datasetFramework.deleteInstance(myTable6);
    }
}

Output:
         List<QueryResult> firstPreview = exploreService.previewResults(handle);
-        Assert.assertEquals(ImmutableList.of(new QueryResult(ImmutableList.<Object>of(MY_TABLE_NAME)), new QueryResult(ImmutableList.<Object>of("String_Node_Str")), new QueryResult(ImmutableList.<Object>of("String_Node_Str")), new QueryResult(ImmutableList.<Object>of("String_Node_Str")), new QueryResult(ImmutableList.<Object>of("String_Node_Str"))), firstPreview);
+        Assert.assertEquals(ImmutableList.of(new QueryResult(ImmutableList.<Object>of(MY_TABLE_NAME)), new QueryResult(ImmutableList.<Object>of(getDatasetHiveName(myTable2))), new QueryResult(ImmutableList.<Object>of(getDatasetHiveName(myTable3))), new QueryResult(ImmutableList.<Object>of(getDatasetHiveName(myTable4))), new QueryResult(ImmutableList.<Object>of(getDatasetHiveName(myTable5)))), firstPreview);
         List<QueryResult> endResults = exploreService.nextResults(handle, 100);


Input:
private void init(View rootView) {
    context = getActivity();
    userPref = new LheidoUtils.UserPref();
    userPref.setUserPref(PreferenceManager.getDefaultSharedPreferences(context));
    name = getArguments().getString(ARG_CONTACT_NAME);
    phoneContact = getArguments().getString(ARG_CONTACT_PHONE);
    conversationId = getArguments().getInt(ARG_CONVERSATION_ID);
    conversation_nb_sms = getArguments().getLong(ARG_CONVERSATION_COUNT);
    liste = (JazzyListView) rootView.findViewById(R.id.list_conversation);
    liste.setTransitionEffect(userPref.conversation_effect);
    liste.setTranscriptMode(ListView.TRANSCRIPT_MODE_NORMAL);
    list_conversationId = getArguments().getInt(ARG_CONVERSATION_NUMBER);
    liste.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
        public boolean onItemLongClick(AdapterView<?> adapterView, View view, int position, long id) {
            int sdk = android.os.Build.VERSION.SDK_INT;
            if (sdk < Build.VERSION_CODES.HONEYCOMB) {
                android.text.ClipboardManager clipboard = (android.text.ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
                clipboard.setText(Message_list.get(Message_list.size() - 1 - position).getBody());
            } else {
                android.content.ClipboardManager clipboard = (android.content.ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
                ClipData clip = ClipData.newPlainText("String_Node_Str", Message_list.get(Message_list.size() - 1 - position).getBody());
                clipboard.setPrimaryClip(clip);
            }
            Toast.makeText(context, "String_Node_Str", Toast.LENGTH_LONG).show();
            return true;
        }
    });
    conversationAdapter = new ConversationAdapter(context, R.layout.message, Message_list);
    liste.setAdapter(conversationAdapter);
    swipeLayout = (SwipeRefreshLayout) rootView.findViewById(R.id.swipe_container);
    swipeLayout.setOnRefreshListener(this);
}

Output:
     });
-    conversationAdapter = new ConversationAdapter(context, R.layout.message, Message_list);
+    conversationAdapter = new ConversationAdapter(context, phoneContact, Message_list);
     liste.setAdapter(conversationAdapter);


Input:
public static Invoker getDeclaredMethod(Class<?> clazz, final String methodName, final Class<?>... parameterTypes) {
    MethodFinder visitor = new MethodFinder(methodName, parameterTypes);
    visitor.accept(clazz.getSuperclass());
    if (visitor.method == null) {
        throw new AssertionError("String_Node_Str" + methodName);
    }
    return new Invoker(visitor.method);
}

Output:
     MethodFinder visitor = new MethodFinder(methodName, parameterTypes);
-    visitor.accept(clazz.getSuperclass());
+    visitor.accept(clazz);
     if (visitor.method == null) {


Input:
public void isConsistent_duplicates() throws Exception {
    Transaction tx = createFakeTx(params, Utils.toNanoCoins(1, 0), myAddress);
    Address someOtherGuy = new ECKey().toAddress(params);
    TransactionOutput output = new TransactionOutput(params, tx, Utils.toNanoCoins(0, 5), someOtherGuy);
    tx.addOutput(output);
    wallet.receiveFromBlock(tx, null, BlockChain.NewBlockType.BEST_CHAIN);
    assertTrue(wallet.isConsistent());
    Transaction txClone = new Transaction(params, tx.bitcoinSerialize());
    try {
        wallet.receiveFromBlock(txClone, null, BlockChain.NewBlockType.SIDE_CHAIN);
        fail();
    } catch (IllegalStateException ex) {
    }
}

Output:
     try {
-        wallet.receiveFromBlock(txClone, null, BlockChain.NewBlockType.SIDE_CHAIN);
+        wallet.receiveFromBlock(txClone, null, BlockChain.NewBlockType.BEST_CHAIN);
         fail();


Input:
public QueryParameter getParameter() {
    return _param;
}

Output:
 public QueryParameter getParameter() {
-    return _param;
+    return param;
 }


Input:
public void writeToParcel(Parcel dest, int flags) {
    if (mServiceUuids == null) {
        dest.writeInt(0);
    } else {
        dest.writeInt(mServiceUuids.size());
        dest.writeList(mServiceUuids);
    }
    dest.writeInt(mManufacturerId);
    if (mManufacturerSpecificData == null) {
        dest.writeInt(0);
    } else {
        dest.writeInt(mManufacturerSpecificData.length);
        dest.writeByteArray(mManufacturerSpecificData);
    }
    if (mServiceDataUuid == null) {
        dest.writeInt(0);
    } else {
        dest.writeInt(1);
        dest.writeParcelable(mServiceDataUuid, flags);
        if (mServiceData == null) {
            dest.writeInt(0);
        } else {
            dest.writeInt(mServiceData.length);
            dest.writeByteArray(mServiceData);
        }
    }
    dest.writeByte((byte) (getIncludeTxPowerLevel() ? 1 : 0));
    dest.writeByte((byte) (getIncludeDeviceName() ? 1 : 0));
}

Output:
 public void writeToParcel(Parcel dest, int flags) {
-    if (mServiceUuids == null) {
-        dest.writeInt(0);
-    } else {
-        dest.writeInt(mServiceUuids.size());
-        dest.writeList(mServiceUuids);
-    }
+    dest.writeList(mServiceUuids);
     dest.writeInt(mManufacturerId);


Input:
protected void doExecute() throws Exception {
    executeQuery();
    if (rsetEmpty) {
        processEmptyQuery();
    }
}

Output:
     executeQuery();
-    if (rsetEmpty) {
-        processEmptyQuery();
+    boolean showIfBlank = "String_Node_Str".equalsIgnoreCase(content.getStyle().getShowIfBlank());
+    if (showIfBlank && rsetEmpty) {
+        createQueryForShowIfBlank();
     }


Input:
private HitEnum buildTermVectorsHitEnum() throws IOException {
    return PostingsHitEnum.fromTermVectors(context.hitContext.reader(), context.hitContext.docId(), context.mapper.fieldType().name(), weigher.acceptableTerms(), getQueryWeigher(false), getCorpusWeigher(false), weigher);
}

Output:
 private HitEnum buildTermVectorsHitEnum() throws IOException {
-    return PostingsHitEnum.fromTermVectors(context.hitContext.reader(), context.hitContext.docId(), context.mapper.fieldType().name(), weigher.acceptableTerms(), getQueryWeigher(false), getCorpusWeigher(false), weigher);
+    return PostingsHitEnum.fromTermVectors(context.hitContext.reader(), context.hitContext.docId(), context.mapper.fieldType().name(), weigher.acceptableTerms(), getQueryWeigher(), getCorpusWeigher(false), weigher);
 }


Input:
public void testRestartClusterTwice() throws Exception {
    HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
    final ClientProperties clientProperties = ClientProperties.crateBaseClientProperties(GroupConfig.DEFAULT_GROUP_NAME, GroupConfig.DEFAULT_GROUP_PASSWORD);
    clientProperties.setPropertyValue(ClientPropertyName.INIT_CONNECTION_ATTEMPTS_LIMIT, "String_Node_Str");
    clientProperties.setPropertyValue(ClientPropertyName.RECONNECTION_ATTEMPTS_LIMIT, "String_Node_Str");
    clientProperties.setPropertyValue(ClientPropertyName.RECONNECTION_TIMEOUT, "String_Node_Str");
    HazelcastClient client = newHazelcastClient(clientProperties, h1);
    final IMap<String, String> map = client.getMap("String_Node_Str");
    final List<String> values = new ArrayList<String>();
    map.addEntryListener(new EntryAdapter<String, String>() {
        public void entryAdded(EntryEvent<String, String> event) {
            values.add(event.getValue());
        }
        public void entryUpdated(EntryEvent<String, String> event) {
            values.add(event.getValue());
        }
    }, true);
    final BlockingQueue<LifecycleState> states = new LinkedBlockingQueue<LifecycleState>();
    client.getLifecycleService().addLifecycleListener(new LifecycleListener() {
        public void stateChanged(LifecycleEvent event) {
            states.add(event.getState());
        }
    });
    map.put("String_Node_Str", "String_Node_Str");
    for (int i = 0; i < 2; i++) {
        h1.getLifecycleService().shutdown();
        assertEquals(LifecycleState.CLIENT_CONNECTION_LOST, states.poll(500L, TimeUnit.MILLISECONDS));
        try {
            map.put("String_Node_Str", "String_Node_Str" + i);
            fail();
        } catch (NoMemberAvailableException e) {
        }
        Thread.sleep(50L);
        try {
            map.put("String_Node_Str", "String_Node_Str" + i);
            fail();
        } catch (NoMemberAvailableException e) {
        }
        Thread.sleep(50L);
        h1 = Hazelcast.newHazelcastInstance(new Config());
        assertEquals(LifecycleState.CLIENT_CONNECTION_OPENING, states.poll(500L, TimeUnit.MILLISECONDS));
        assertEquals(LifecycleState.CLIENT_CONNECTION_OPENED, states.poll(1000L, TimeUnit.MILLISECONDS));
        map.put("String_Node_Str", "String_Node_Str" + i);
        Thread.sleep(50L);
    }
    assertArrayEquals(values.toString(), new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" }, values.toArray(new String[0]));
}

Output:
     HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
-    final ClientProperties clientProperties = ClientProperties.crateBaseClientProperties(GroupConfig.DEFAULT_GROUP_NAME, GroupConfig.DEFAULT_GROUP_PASSWORD);
+    final ClientProperties clientProperties = ClientProperties.createBaseClientProperties(GroupConfig.DEFAULT_GROUP_NAME, GroupConfig.DEFAULT_GROUP_PASSWORD);
     clientProperties.setPropertyValue(ClientPropertyName.INIT_CONNECTION_ATTEMPTS_LIMIT, "String_Node_Str");


Input:
private Rect readLiveBoundsOfScrollView() {
    Rect scrollViewBounds = new Rect();
    CustomScrollView scrollView = (CustomScrollView) CamerasActivity.this.findViewById(R.id.cameras_scroll_view);
    scrollView.getDrawingRect(scrollViewBounds);
    Log.d(TAG, scrollViewBounds.top + "String_Node_Str" + scrollViewBounds.bottom + "String_Node_Str" + scrollViewBounds.left + "String_Node_Str" + scrollViewBounds.right);
    Rect rectWithExtension = new Rect(scrollViewBounds.left, scrollViewBounds.top, scrollViewBounds.right, scrollViewBounds.bottom + 300);
    Log.d(TAG, "String_Node_Str" + rectWithExtension.top + "String_Node_Str" + rectWithExtension.bottom + "String_Node_Str" + rectWithExtension.left + "String_Node_Str" + rectWithExtension.right);
    return rectWithExtension;
}

Output:
     CustomScrollView scrollView = (CustomScrollView) CamerasActivity.this.findViewById(R.id.cameras_scroll_view);
-    scrollView.getDrawingRect(scrollViewBounds);
-    Log.d(TAG, scrollViewBounds.top + "String_Node_Str" + scrollViewBounds.bottom + "String_Node_Str" + scrollViewBounds.left + "String_Node_Str" + scrollViewBounds.right);
-    Rect rectWithExtension = new Rect(scrollViewBounds.left, scrollViewBounds.top, scrollViewBounds.right, scrollViewBounds.bottom + 300);
-    Log.d(TAG, "String_Node_Str" + rectWithExtension.top + "String_Node_Str" + rectWithExtension.bottom + "String_Node_Str" + rectWithExtension.left + "String_Node_Str" + rectWithExtension.right);
-    return rectWithExtension;
+    return scrollView.getLiveBoundsRect();
 }


Input:
public boolean onNavigationItemSelected(MenuItem item) {
    int id = item.getItemId();
    if (id == R.id.nav_camera) {
        batchManager.addToBatch(Collections.singleton(new TagData(perfTag, "String_Node_Str")));
    } else if (id == R.id.nav_gallery) {
        batchManager.addToBatch(Collections.singleton(new TagData(dgTag, "String_Node_Str")));
    } else if (id == R.id.nav_slideshow) {
        batchManager.addToBatch(Collections.singleton(new TagData(debugTag, "String_Node_Str")));
    } else if (id == R.id.nav_manage) {
        batchManager.addToBatch(Collections.singleton(new TagData(perfTag, "String_Node_Str")));
    } else if (id == R.id.nav_share) {
        batchManager.addToBatch(Collections.singleton(new TagData(dgTag, "String_Node_Str")));
    } else if (id == R.id.nav_send) {
        batchManager.addToBatch(Collections.singleton(new TagData(perfTag, "String_Node_Str")));
    }
    DrawerLayout drawer = (DrawerLayout) findViewById(R.id.drawer_layout);
    drawer.closeDrawer(GravityCompat.START);
    return true;
}

Output:
     if (id == R.id.nav_camera) {
-        batchManager.addToBatch(Collections.singleton(new TagData(perfTag, "String_Node_Str")));
+        batchManager.addToBatch(Collections.singleton(new TagData(perfTag, "String_Node_Str" + System.currentTimeMillis())));
     } else if (id == R.id.nav_gallery) {


Input:
protected void initHeaders() {
    headers.add(MatchAnalysisConstant.MATCH_KEY_NAME);
    if (isShowInputColumn) {
        headers.add(MatchAnalysisConstant.INPUT_COLUMN);
    }
    headers.add(MatchAnalysisConstant.MATCHING_TYPE);
    headers.add(MatchAnalysisConstant.CUSTOM_MATCHER);
    headers.add(MatchAnalysisConstant.THRESHOLD);
    headers.add(MatchAnalysisConstant.CONFIDENCE_WEIGHT);
    headers.add(MatchAnalysisConstant.HANDLE_NULL);
    headers.add(MatchAnalysisConstant.FUNCTION);
    headers.add(MatchAnalysisConstant.PARAMETER);
}

Output:
 protected void initHeaders() {
-    headers.add(MatchAnalysisConstant.MATCH_KEY_NAME);
+    headers.add(DefaultMessagesImpl.getString(MatchAnalysisConstant.MATCH_KEY_NAME));
     if (isShowInputColumn) {


Input:
public void testCreateNonExistant() {
    StaticUser user = new StaticUser();
    user.setName("String_Node_Str");
    user.setId(102);
    user = restCreate(user, "String_Node_Str", StaticUser.class, true);
}

Output:
     user.setId(102);
-    user = restCreate(user, "String_Node_Str", StaticUser.class, true);
+    user = restCreate(user, "String_Node_Str", StaticUser.class);
 }


Input:
public ItemStack getStackInSlot(int i) {
    if (inventory != null) {
        return inventory.getStackInSlot(i);
    } else {
        return container.getSlot(i).getStack();
    }
}

Output:
 public ItemStack getStackInSlot(int i) {
-    if (inventory != null) {
+    if (inventory != null)
         return inventory.getStackInSlot(i);


Input:
private void computeTimeOut() {
    long currentTime = System.currentTimeMillis();
    timeOutReached = ((currentTime - startTime) >= (timeOutSeconds * 1000));
}

Output:
     long currentTime = System.currentTimeMillis();
-    timeOutReached = ((currentTime - startTime) >= (timeOutSeconds * 1000));
+    timeOutReached = ((currentTime - startTime) >= (timeOutSeconds * 1000L));
 }


Input:
public int compareTo(Playlist o) {
    return title.compareTo(o.getTitle());
}

Output:
 public int compareTo(Playlist o) {
-    return title.compareTo(o.getTitle());
+    return title.toLowerCase().compareTo(o.getTitle().toLowerCase());
 }


Input:
public void handleEvent(Event event) {
    if (event.widget.equals(wliacLine)) {
        boolean isUnset = (event.detail == ChartElementUtil.PROPERTY_UNSET);
        if (event.type == LineAttributesComposite.VISIBILITY_CHANGED_EVENT) {
            ChartElementUtil.setEObjectAttribute(series.getWebLineAttributes(), "String_Node_Str", ((Boolean) event.data).booleanValue(), isUnset);
        } else if (event.type == LineAttributesComposite.STYLE_CHANGED_EVENT) {
            ChartElementUtil.setEObjectAttribute(series.getWebLineAttributes(), "String_Node_Str", (LineStyle) event.data, isUnset);
        } else if (event.type == LineAttributesComposite.WIDTH_CHANGED_EVENT) {
            ChartElementUtil.setEObjectAttribute(series.getWebLineAttributes(), "String_Node_Str", ((Integer) event.data).intValue(), isUnset);
        } else if (event.type == LineAttributesComposite.COLOR_CHANGED_EVENT) {
            series.getWebLineAttributes().setColor((ColorDefinition) event.data);
        }
    } else if (event.widget.equals(webMin)) {
        double tmin = this.getTypedDataElement(webMin.getText());
        double tmax = this.getTypedDataElement(webMax.getText());
        if (tmin > tmax)
            tmin = tmax;
        series.setWebLabelMin(tmin);
        webMin.setText(Double.toString(tmin));
    } else if (event.widget.equals(webMax)) {
        double tmin = this.getTypedDataElement(webMin.getText());
        double tmax = this.getTypedDataElement(webMax.getText());
        if (tmax < tmin)
            tmax = tmin;
        series.setWebLabelMax(tmax);
        webMax.setText(Double.toString(tmax));
    } else if (event.widget.equals(btnTranslucentBullseye)) {
        ChartElementUtil.setEObjectAttribute(series, "String_Node_Str", btnTranslucentBullseye.getSelectionState() == TristateCheckbox.STATE_SELECTED, btnTranslucentBullseye.getSelectionState() == TristateCheckbox.STATE_GRAYED);
    } else if (event.widget.equals(iscScaleCnt)) {
        series.setPlotSteps(BigInteger.valueOf(iscScaleCnt.getSelection()));
    } else if (event.widget.equals(btnAutoScale)) {
        ChartElementUtil.setEObjectAttribute(series, "String_Node_Str", btnAutoScale.getSelectionState() == TristateCheckbox.STATE_SELECTED, btnAutoScale.getSelectionState() == TristateCheckbox.STATE_GRAYED);
        boolean enabled = btnAutoScale.getSelectionState() == TristateCheckbox.STATE_SELECTED;
        updateScaleUI(enabled);
    } else if (event.widget == btnScaleCntAuto) {
        ChartElementUtil.setEObjectAttribute(series, "String_Node_Str", BigInteger.valueOf(iscScaleCnt.getSelection()), btnScaleCntAuto.getSelection());
        iscScaleCnt.setEnabled(btnAutoScale.getSelectionState() != TristateCheckbox.STATE_GRAYED && !btnScaleCntAuto.getSelection());
    } else if (event.widget == btnWebMinAuto) {
        double tmin = this.getTypedDataElement(webMin.getText());
        double tmax = this.getTypedDataElement(webMax.getText());
        if (tmin > tmax)
            tmin = tmax;
        ChartElementUtil.setEObjectAttribute(series, "String_Node_Str", tmin, btnWebMinAuto.getSelection());
        webMin.setEnabled(!btnWebMinAuto.getSelection());
    } else if (event.widget == btnWebMaxAuto) {
        double tmin = this.getTypedDataElement(webMin.getText());
        double tmax = this.getTypedDataElement(webMax.getText());
        if (tmax < tmin)
            tmax = tmin;
        ChartElementUtil.setEObjectAttribute(series, "String_Node_Str", tmax, btnWebMaxAuto.getSelection());
        webMax.setEnabled(!btnWebMaxAuto.getSelection());
    }
}

Output:
         } else if (event.type == LineAttributesComposite.STYLE_CHANGED_EVENT) {
-            ChartElementUtil.setEObjectAttribute(series.getWebLineAttributes(), "String_Node_Str", (LineStyle) event.data, isUnset);
+            ChartElementUtil.setEObjectAttribute(series.getWebLineAttributes(), "String_Node_Str", event.data, isUnset);
         } else if (event.type == LineAttributesComposite.WIDTH_CHANGED_EVENT) {


Input:
protected void onPostExecute(List<com.fanfou.app.api.Status> result) {
    if (!showListView) {
        showContent();
    }
    if (result != null && result.size() > 0) {
        int size = result.size();
        log("String_Node_Str" + size);
        maxId = result.get(size - 1).id;
        log("String_Node_Str" + maxId);
        mStatuses.addAll(result);
        updateUI(size < 20);
    }
    mPullToRefreshListView.onRefreshComplete();
}

Output:
 protected void onPostExecute(List<com.fanfou.app.api.Status> result) {
-    if (!showListView) {
-        showContent();
-    }
+    mPullToRefreshListView.onRefreshComplete();
     if (result != null && result.size() > 0) {


Input:
private void parseWorkflow(AbstractWorkflowDataModel wfdm) {
    boolean metadatawriteback = Boolean.parseBoolean(wfdm.getConfigs().get("String_Node_Str"));
    List<PegasusJob> parents = new ArrayList<PegasusJob>();
    AbstractJob job0 = new BashJob("String_Node_Str");
    job0.getCommand().addArgument("String_Node_Str");
    if (!wfdm.getDirectories().isEmpty()) {
        for (String dir : wfdm.getDirectories()) {
            job0.getCommand().addArgument("String_Node_Str" + dir + "String_Node_Str");
        }
    }
    PegasusJob pjob0 = new PegasusJob(job0, wfdm.getWorkflowBaseDir());
    pjob0.setId(this.jobs.size());
    pjob0.setMetadataWriteback(metadatawriteback);
    String parentAccession = wfdm.getParent_accessions();
    if (parentAccession != null && !parentAccession.isEmpty()) {
        pjob0.setParentAccession(parentAccession);
    }
    String workflowRunAccession = wfdm.getWorkflow_run_accession();
    if (workflowRunAccession != null && !workflowRunAccession.isEmpty()) {
        pjob0.setWorkflowRunAccession(workflowRunAccession);
        pjob0.setWorkflowRunAncesstor(true);
    }
    this.jobs.add(pjob0);
    parents.add(pjob0);
    if (!wfdm.getFiles().isEmpty()) {
        Collection<PegasusJob> newParents = new ArrayList<PegasusJob>();
        for (Map.Entry<String, SqwFile> entry : wfdm.getFiles().entrySet()) {
            AbstractJob job = new BashJob("String_Node_Str" + entry.getKey());
            job.addFile(entry.getValue());
            ProvisionFilesJob pjob = new ProvisionFilesJob(job, wfdm.getWorkflowBaseDir(), entry.getValue());
            pjob.setId(this.jobs.size());
            pjob.setMetadataWriteback(metadatawriteback);
            if (workflowRunAccession != null && !workflowRunAccession.isEmpty()) {
                pjob.setWorkflowRunAccession(workflowRunAccession);
            }
            this.jobs.add(pjob);
            this.fileJobMap.put(entry.getValue(), pjob);
            if (entry.getValue().isInput()) {
                newParents.add(pjob);
                for (PegasusJob parent : parents) {
                    pjob.addParent(parent);
                }
                String outputDir = "String_Node_Str" + entry.getValue().getUniqueDir();
                job0.getCommand().addArgument("String_Node_Str" + outputDir + "String_Node_Str");
                pjob.setOutputDir(outputDir);
            } else {
                pjob.setMetadataOutputPrefix(wfdm.getMetadata_output_file_prefix());
                pjob.setOutputDir(wfdm.getMetadata_output_dir());
            }
        }
        parents.clear();
        parents.addAll(newParents);
    }
    int idCount = this.jobs.size();
    Map<PegasusJob, PegasusJob> hasProvisionOut = new HashMap<PegasusJob, PegasusJob>();
    for (AbstractJob job : wfdm.getWorkflow().getJobs()) {
        PegasusJob pjob = this.createPegasusJobObject(job, wfdm);
        pjob.setId(idCount);
        pjob.setMetadataWriteback(metadatawriteback);
        if (workflowRunAccession != null && !workflowRunAccession.isEmpty()) {
            pjob.setWorkflowRunAccession(workflowRunAccession);
        }
        this.jobs.add(pjob);
        idCount++;
        for (Job parent : job.getParents()) {
            pjob.addParent(this.getPegasusJobObject((AbstractJob) parent));
        }
        if (job.getFiles().isEmpty() == false) {
            for (SqwFile file : job.getFiles()) {
                if (file.isInput()) {
                    AbstractJob pfjob = new BashJob("String_Node_Str");
                    pfjob.addFile(file);
                    ProvisionFilesJob parentPfjob = new ProvisionFilesJob(pfjob, wfdm.getWorkflowBaseDir(), file);
                    parentPfjob.setId(this.jobs.size());
                    parentPfjob.addParent(pjob0);
                    parentPfjob.setMetadataWriteback(metadatawriteback);
                    if (workflowRunAccession != null && !workflowRunAccession.isEmpty()) {
                        parentPfjob.setWorkflowRunAccession(workflowRunAccession);
                    }
                    this.jobs.add(parentPfjob);
                    parentPfjob.setOutputDir(file.getProvisionedPath());
                    pjob.addParent(parentPfjob);
                    job0.getCommand().addArgument("String_Node_Str" + file.getProvisionedPath() + "String_Node_Str");
                } else {
                    AbstractJob pfjob = new BashJob("String_Node_Str");
                    pfjob.addFile(file);
                    ProvisionFilesJob parentPfjob = new ProvisionFilesJob(pfjob, wfdm.getWorkflowBaseDir(), file);
                    parentPfjob.setId(this.jobs.size());
                    parentPfjob.addParent(pjob);
                    parentPfjob.setMetadataWriteback(metadatawriteback);
                    parentPfjob.setMetadataOutputPrefix(wfdm.getMetadata_output_file_prefix());
                    parentPfjob.setOutputDir(wfdm.getMetadata_output_dir());
                    if (workflowRunAccession != null && !workflowRunAccession.isEmpty()) {
                        parentPfjob.setWorkflowRunAccession(workflowRunAccession);
                    }
                    this.jobs.add(parentPfjob);
                    hasProvisionOut.put(pjob, parentPfjob);
                }
            }
        }
        if (pjob.getParents().isEmpty()) {
            for (PegasusJob parent : parents) {
                pjob.addParent(parent);
            }
        }
    }
    if (!hasProvisionOut.isEmpty()) {
        for (Map.Entry<PegasusJob, PegasusJob> entry : hasProvisionOut.entrySet()) {
            Collection<PegasusJob> children = entry.getKey().getChildren();
            if (children.size() <= 1)
                continue;
            for (PegasusJob child : children) {
                if (child == entry.getValue())
                    continue;
                child.addParent(entry.getValue());
            }
        }
    }
    List<PegasusJob> leaves = new ArrayList<PegasusJob>();
    for (PegasusJob _job : this.jobs) {
        if (_job.getChildren().isEmpty()) {
            leaves.add(_job);
        }
    }
    for (Map.Entry<SqwFile, PegasusJob> entry : fileJobMap.entrySet()) {
        if (entry.getKey().isOutput()) {
            for (PegasusJob leaf : leaves) {
                if (leaf != entry.getValue())
                    entry.getValue().addParent(leaf);
            }
        }
    }
    this.setAccessionFileRelations(pjob0);
}

Output:
                     this.jobs.add(parentPfjob);
-                    parentPfjob.setOutputDir(file.getProvisionedPath());
+                    parentPfjob.setOutputDir("String_Node_Str" + file.getUniqueDir());
                     pjob.addParent(parentPfjob);


Input:
private void createParameterUISection(IParameterDefn[] params) {
    txtParams = new Text[params.length];
    for (int i = 0; i < params.length; i++) {
        IParameterDefn param = params[i];
        Label paramLabel = new Label(parameterContainer, SWT.NONE | SWT.WRAP);
        paramLabel.setText(Utility.getNonNullString(param.getDisplayName()));
        GridData gd = new GridData();
        final int widthHint = firstLabel.computeSize(-1, -1).x - firstLabel.getBorderWidth();
        gd.widthHint = widthHint;
        paramLabel.setLayoutData(gd);
        Composite composite = ControlProvider.getDefaultComposite(parameterContainer);
        if (param.isDataField()) {
            String text = BLANK;
            if (lastExpression != null) {
                text = lastExpression;
            } else {
                text = (String) getProperty(getStructureOrHandle(), cellProperties[EXPRESSION_INDEX]);
            }
            txtParams[i] = ControlProvider.createText(composite, text);
            final Text txtDataField = txtParams[i];
            txtDataField.setLayoutData(ControlProvider.getGridDataWithHSpan(1));
            txtDataField.addModifyListener(new ModifyListener() {
                public void modifyText(ModifyEvent e) {
                    lastExpression = txtDataField.getText();
                    validateSyntax();
                }
            });
        } else {
            Text txtArgument = ControlProvider.createText(composite, null);
            txtArgument.setLayoutData(ControlProvider.getGridDataWithHSpan(1));
            txtArgument.addModifyListener(new ModifyListener() {
                public void modifyText(ModifyEvent e) {
                    validateSyntax();
                }
            });
            txtParams[i] = txtArgument;
        }
        txtParams[i].setToolTipText(param.getDescription());
        createExpressionButton(composite, txtParams[i]);
    }
    updateParametersText(params);
}

Output:
         GridData gd = new GridData();
-        final int widthHint = firstLabel.computeSize(-1, -1).x - firstLabel.getBorderWidth();
-        gd.widthHint = widthHint;
+        this.maxWidth = computeMaxWidth(paramLabel);
+        gd.widthHint = this.maxWidth;
         paramLabel.setLayoutData(gd);


Input:
public List<String> getSearchResult() {
    List<String> mainSearchResult = super.getSearchResult();
    try {
        Integer userType = this.getUserType();
        if (null == userType || userType == 0) {
            return mainSearchResult;
        } else {
            Boolean entandoUser = userType.intValue() == 1;
            List<String> ldapUsernames = this.getLdapUsernames();
            if (entandoUser) {
                return (List<String>) CollectionUtils.removeAll(mainSearchResult, ldapUsernames);
            } else {
                return (List<String>) CollectionUtils.intersection(mainSearchResult, ldapUsernames);
            }
        }
    } catch (Throwable t) {
        ApsSystemUtils.logThrowable(t, this, "String_Node_Str");
        throw new RuntimeException("String_Node_Str", t);
    }
}

Output:
         } else {
-            Boolean entandoUser = userType.intValue() == 1;
+            Boolean entandoUser = (userType == 1);
             List<String> ldapUsernames = this.getLdapUsernames();


Input:
public void debugPrintln(String str, int level) {
    if (level <= getLogLevel()) {
        if (m_printBuf.length() > 0) {
            m_printBuf.append(str);
            logOutput(m_printBuf.toString(), level);
            m_printBuf.setLength(0);
        } else
            logOutput(str, level);
    }
}

Output:
     if (level <= getLogLevel()) {
-        if (m_printBuf.length() > 0) {
-            m_printBuf.append(str);
-            logOutput(m_printBuf.toString(), level);
-            m_printBuf.setLength(0);
-        } else
-            logOutput(str, level);
+        switch(level) {
+            case Debug.Debug:
+                logger.debug(ex, ex);
+                break;
+            case Debug.Info:
+                logger.info(ex, ex);
+                break;
+            case Debug.Warn:
+                logger.warn(ex, ex);
+                break;
+            case Debug.Fatal:
+                logger.fatal(ex, ex);
+                break;
+            case Debug.Error:
+                logger.error(ex, ex);
+                break;
+        }
     }


Input:
protected void prepareParameters() throws ReportServiceException, RemoteException {
    __bean = context.getBean();
    __docName = __getReportDocument();
    __checkDocumentExists();
    InputOptions getPageCountOptions = new InputOptions();
    getPageCountOptions.setOption(InputOptions.OPT_LOCALE, __bean.getLocale());
    getPageCountOptions.setOption(InputOptions.OPT_RTL, new Boolean(__bean.isRtl()));
    getPageCountOptions.setOption(InputOptions.OPT_REQUEST, context.getRequest());
    OutputOptions outputOptions = new OutputOptions();
    InputOptions options = new InputOptions();
    __totalPageNumber = getReportService().getPageCount(__docName, getPageCountOptions, outputOptions);
    Boolean isCompleted = (Boolean) outputOptions.getOption(OutputOptions.OPT_REPORT_GENERATION_COMPLETED);
    if (isCompleted != null) {
        __isCompleted = isCompleted.booleanValue();
    }
    __bookmark = getBookmark(operation.getOprand(), __bean);
    if (isToc(operation.getOprand(), __bean)) {
        __bookmark = (getReportService()).findTocByName(__docName, __bookmark, options);
    }
    __pageNumber = getPageNumber(context.getRequest(), operation.getOprand(), __docName);
    if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
        options.setOption(InputOptions.OPT_REQUEST, context.getRequest());
        __pageNumber = getReportService().getPageNumberByBookmark(__docName, __bookmark, options);
        if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
            AxisFault fault = new AxisFault();
            fault.setFaultReason(BirtResources.getFormattedString(ResourceConstants.ACTION_EXCEPTION_INVALID_BOOKMARK, new String[] { __bookmark }));
            throw fault;
        }
        __useBookmark = true;
    }
    if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
        AxisFault fault = new AxisFault();
        fault.setFaultReason(BirtResources.getString(ResourceConstants.ACTION_EXCEPTION_INVALID_PAGE_NUMBER));
        throw fault;
    }
    __svgFlag = getSVGFlag(operation.getOprand());
}

Output:
         if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
-            AxisFault fault = new AxisFault();
-            fault.setFaultReason(BirtResources.getFormattedString(ResourceConstants.ACTION_EXCEPTION_INVALID_BOOKMARK, new String[] { __bookmark }));
-            throw fault;
+            __bookmark = (getReportService()).findTocByName(__docName, __bookmark, options);
+            __pageNumber = getReportService().getPageNumberByBookmark(__docName, __bookmark, options);
+            if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
+                AxisFault fault = new AxisFault();
+                fault.setFaultReason(BirtResources.getFormattedString(ResourceConstants.ACTION_EXCEPTION_INVALID_BOOKMARK, new String[] { __bookmark }));
+                throw fault;
+            }
+            __useBookmark = true;
         }


Input:
public Boolean getStopGracefully() {
    return stopGracefully == null ? false : stopGracefully;
}

Output:
 public Boolean getStopGracefully() {
-    return stopGracefully == null ? false : stopGracefully;
+    return stopGracefully == null ? true : stopGracefully;
 }


Input:
protected Actor _dequeueEvents() {
    Actor actorToFire = null;
    DEEvent currentEvent = null, nextEvent = null;
    int currentDepth = 0;
    if (_eventQueue == null)
        return null;
    while (true) {
        if (_stopWhenQueueIsEmpty) {
            if (_eventQueue.isEmpty()) {
                break;
            } else {
                nextEvent = (DEEvent) _eventQueue.get();
            }
        } else {
            if (actorToFire != null && _eventQueue.isEmpty())
                break;
            while (_eventQueue.isEmpty() && !_stopRequested) {
                if (_debugging) {
                    _debug("String_Node_Str");
                }
                Thread.currentThread().yield();
                if (_debugging) {
                    _debug("String_Node_Str");
                }
                synchronized (_eventQueue) {
                    if (_eventQueue.isEmpty()) {
                        try {
                            if (_debugging) {
                                _debug("String_Node_Str");
                            }
                            _eventQueue.wait();
                            if (_debugging) {
                                _debug("String_Node_Str");
                            }
                        } catch (InterruptedException e) {
                            if (_debugging) {
                                _debug("String_Node_Str" + "String_Node_Str");
                            }
                            break;
                        } catch (Exception e) {
                            if (_debugging) {
                                _debug("String_Node_Str");
                            }
                        }
                    }
                }
            }
            if (_eventQueue.isEmpty()) {
                break;
            } else {
                nextEvent = (DEEvent) _eventQueue.get();
            }
        }
        if (actorToFire == null) {
            double currentTime;
            if (!_synchronizeToRealTime) {
                currentEvent = (DEEvent) _eventQueue.get();
                currentTime = currentEvent.timeStamp();
            } else {
                synchronized (_eventQueue) {
                    while (true) {
                        currentEvent = (DEEvent) _eventQueue.get();
                        currentTime = currentEvent.timeStamp();
                        long elapsedTime = System.currentTimeMillis() - _realStartTime;
                        double elapsedTimeInSeconds = ((double) elapsedTime) / 1000.0;
                        if (currentTime <= elapsedTimeInSeconds) {
                            break;
                        }
                        long timeToWait = (long) ((currentTime - elapsedTimeInSeconds) * 1000.0);
                        if (timeToWait > 0) {
                            if (_debugging) {
                                _debug("String_Node_Str" + timeToWait);
                            }
                            try {
                                _eventQueue.wait(timeToWait);
                            } catch (InterruptedException ex) {
                            }
                        }
                    }
                }
            }
            synchronized (_eventQueue) {
                currentEvent = (DEEvent) _eventQueue.take();
                currentTime = currentEvent.timeStamp();
                actorToFire = currentEvent.actor();
                if (_disabledActors != null && _disabledActors.contains(actorToFire)) {
                    if (_debugging)
                        _debug("String_Node_Str", ((Nameable) actorToFire).getFullName());
                    actorToFire = null;
                    continue;
                }
                try {
                    setCurrentTime(currentTime);
                } catch (IllegalActionException ex) {
                    throw new InternalErrorException(this, ex, null);
                }
            }
            currentDepth = currentEvent.depth();
            _microstep = currentEvent.microstep();
            if (currentTime > getStopTime()) {
                if (_debugging) {
                    _debug("String_Node_Str");
                }
                _exceedStopTime = true;
                return null;
            }
            DEReceiver receiver = currentEvent.receiver();
            if (receiver != null) {
                if (_debugging)
                    _debug(getName(), "String_Node_Str", receiver.getContainer().getFullName());
                receiver._triggerEvent(currentEvent.token());
            }
        } else {
            if (nextEvent.isSimultaneousWith(currentEvent) && nextEvent.actor() == currentEvent.actor()) {
                _eventQueue.take();
                DEReceiver receiver = nextEvent.receiver();
                if (receiver != null) {
                    receiver._triggerEvent(nextEvent.token());
                }
            } else {
                break;
            }
        }
    }
    return actorToFire;
}

Output:
         return null;
-    while (true) {
+    while (!_stopRequested) {
         if (_stopWhenQueueIsEmpty) {


Input:
public String toString() {
    return "String_Node_Str" + "String_Node_Str" + exceptionOperation + "String_Node_Str" + "String_Node_Str" + syncopeUserId + "String_Node_Str" + "String_Node_Str" + workflowEntryId + '}';
}

Output:
 public String toString() {
-    return "String_Node_Str" + "String_Node_Str" + exceptionOperation + "String_Node_Str" + "String_Node_Str" + syncopeUserId + "String_Node_Str" + "String_Node_Str" + workflowEntryId + '}';
+    return "String_Node_Str" + "String_Node_Str" + exceptionOperation + "String_Node_Str" + "String_Node_Str" + syncopeUserId + "String_Node_Str" + "String_Node_Str" + workflowId + "String_Node_Str" + "String_Node_Str" + workflowEntryId + '}';
 }


Input:
public void onResponse(Response<UserResponse> response, Retrofit retrofit) {
    if (isDestroyed() || isFinishing())
        return;
    if (response != null && response.body() != null) {
        UserResponse userResponse = response.body();
        if (mSelectedUser != null) {
            mSelectedUser.copy(userResponse.data);
        } else {
            mSelectedUser = userResponse.data;
        }
        mSelectedUser.setLastSeen(System.currentTimeMillis());
        if (mSelectedUser.isSelf(app) && !TextUtils.isEmpty(mSelectedUser.getAccessToken())) {
            SqlHelper.getInstance(getApplicationContext()).updateUserInfo(mSelectedUser);
        } else {
            SqlHelper.getInstance(getApplicationContext()).insertProfile(mSelectedUser);
        }
        mAdapter = new ProfilePager(getApplicationContext(), getFragmentManager(), mSelectedUser);
        mPager.setAdapter(mAdapter);
        mSlidingTabs.setupWithViewPager(mPager);
        mMultiView.setViewState(MultiStateView.VIEW_STATE_CONTENT);
        supportInvalidateOptionsMenu();
    } else {
        ViewUtils.setErrorText(mMultiView, R.id.errorMessage, R.string.error_generic);
        mMultiView.setViewState(MultiStateView.VIEW_STATE_ERROR);
    }
}

Output:
     } else {
-        ViewUtils.setErrorText(mMultiView, R.id.errorMessage, R.string.error_generic);
+        ViewUtils.setErrorText(mMultiView, R.id.errorMessage, getString(R.string.profile_not_found, username));
         mMultiView.setViewState(MultiStateView.VIEW_STATE_ERROR);


Input:
private static boolean isSetHelper(VM_Address start, int size, boolean verbose, int v) throws VM_PragmaNoInline {
    if (VM_Interface.VerifyAssertions)
        VM_Interface._assert(size == (size & (~3)));
    for (int i = 0; i < size; i += 4) if (VM_Magic.getMemoryInt(start.add(i)) != v) {
        if (verbose) {
            Log.prependThreadId();
            Log.write("String_Node_Str");
            Log.writeln(v);
            Log.write("String_Node_Str");
            Log.write(start);
            Log.write("String_Node_Str");
            Log.writeln(start.add(size));
            Log.write("String_Node_Str");
            Log.writeln(start.add(i));
            dumpMemory(start, 0, size);
        }
        return false;
    }
    return true;
}

Output:
     if (VM_Interface.VerifyAssertions)
-        VM_Interface._assert(size == (size & (~3)));
-    for (int i = 0; i < size; i += 4) if (VM_Magic.getMemoryInt(start.add(i)) != v) {
+        VM_Interface._assert((size & (BYTES_IN_INT - 1)) == 0);
+    for (int i = 0; i < size; i += BYTES_IN_INT) if (VM_Magic.getMemoryInt(start.add(i)) != v) {
         if (verbose) {


Input:
public void show() {
    hidden = false;
    refreshPanel();
}

Output:
     hidden = false;
-    refreshPanel();
+    Component p = getPanel();
+    this.setFrameVisible(true);
+    this.setPanelVisible(true);
+    refreshPanel(p);
 }


Input:
public static String execToString(final String cmd, final boolean addStdErr, final boolean checkExitCode) throws IOException {
    logger.fine("String_Node_Str" + Thread.currentThread().getId() + "String_Node_Str" + cmd);
    final long startTime = System.currentTimeMillis();
    Process p = Runtime.getRuntime().exec(new String[] { "String_Node_Str", "String_Node_Str", cmd });
    InputStream std = p.getInputStream();
    BufferedReader stdr = new BufferedReader(new InputStreamReader(std, CHARSET));
    StringBuffer sb = new StringBuffer();
    String l1 = null;
    while ((l1 = stdr.readLine()) != null) {
        sb.append(l1);
        sb.append('\n');
    }
    InputStream err = p.getErrorStream();
    BufferedReader errr = new BufferedReader(new InputStreamReader(err, CHARSET));
    String l2 = null;
    while ((l2 = errr.readLine()) != null) if (addStdErr) {
        sb.append(l2);
        sb.append('\n');
    } else
        System.err.println(l2);
    stdr.close();
    errr.close();
    if (checkExitCode)
        logEndTime(p, cmd, startTime);
    return sb.toString();
}

Output:
     final long startTime = System.currentTimeMillis();
-    Process p = Runtime.getRuntime().exec(new String[] { "String_Node_Str", "String_Node_Str", cmd });
-    InputStream std = p.getInputStream();
-    BufferedReader stdr = new BufferedReader(new InputStreamReader(std, CHARSET));
-    StringBuffer sb = new StringBuffer();
+    final Process p = Runtime.getRuntime().exec(new String[] { "String_Node_Str", "String_Node_Str", cmd });
+    final InputStream std = p.getInputStream();
+    final BufferedReader stdr = new BufferedReader(new InputStreamReader(std, CHARSET));
+    final StringBuilder sb = new StringBuilder();
     String l1 = null;


Input:
public void onAnimationEnd(Animator animation) {
    if (mDimmed) {
        mBackgroundNormal.setVisibility(View.INVISIBLE);
    }
}

Output:
 public void onAnimationEnd(Animator animation) {
-    if (mDimmed) {
-        mBackgroundNormal.setVisibility(View.INVISIBLE);
-    }
+    updateBackground();
 }


Input:
public static int silent(Player player, String[] args) {
    if (player.canUseCommand("String_Node_Str")) {
        vMinecraftUsers.getProfile(player).setSilent();
        player.sendMessage(Colors.DarkPurple + "String_Node_Str");
        return EXIT_SUCCESS;
    }
    return EXIT_FAIL;
}

Output:
     if (player.canUseCommand("String_Node_Str")) {
-        vMinecraftUsers.getProfile(player).setSilent();
-        player.sendMessage(Colors.DarkPurple + "String_Node_Str");
-        return EXIT_SUCCESS;
+        if (!vMinecraftUsers.getProfile(player).isSilent()) {
+            vMinecraftUsers.getProfile(player).setSilent();
+            player.sendMessage(Colors.DarkPurple + "String_Node_Str");
+            return EXIT_SUCCESS;
+        }
+        if (vMinecraftUsers.getProfile(player).isSilent()) {
+            vMinecraftUsers.getProfile(player).disableSilent();
+            player.sendMessage(Colors.DarkPurple + "String_Node_Str");
+            return EXIT_SUCCESS;
+        }
+        return EXIT_FAIL;
     }


Input:
public Collection<SerialMessage> getDynamicValues(boolean refresh) {
    ArrayList<SerialMessage> result = new ArrayList<SerialMessage>();
    if (refresh == true) {
        initialiseName = false;
        initialiseLocation = false;
    }
    if (initialiseName == false) {
        result.add(this.getNameMessage());
    }
    if (initialiseLocation == false) {
        result.add(this.getLocationMessage());
    }
    return result;
}

Output:
     if (initialiseName == false) {
-        result.add(this.getNameMessage());
+        result.add(getNameMessage());
     }


Input:
public void start(Brain brain) {
    Vector2f position = brain.getEntityOwner().getPos();
    PathFeeder<?> feeder = brain.getMotion().getPathFeeder();
    if (this.zonesToAvoid.isEmpty()) {
        feeder.findFuzzyPath(position, this.destination, this.fuzzyNess);
    } else {
        feeder.findAvoidancePath(position, this.destination, this.zonesToAvoid);
    }
}

Output:
 public void start(Brain brain) {
-    Vector2f position = brain.getEntityOwner().getPos();
-    PathFeeder<?> feeder = brain.getMotion().getPathFeeder();
+    Vector2f position = brain.getEntityOwner().getCenterPos();
+    PathPlanner<?> feeder = brain.getMotion().getPathPlanner();
     if (this.zonesToAvoid.isEmpty()) {


Input:
protected void queryPlaylistsInternal(final String library, final Subscriber<List<Playlist>> subscriber, final Bundle args) {
    Observable.create(new Observable.OnSubscribe<Playlist>() {
        public void call(Subscriber<? super Playlist> subscriber) {
            queryPlaylists(library, subscriber, args);
        }
    }).subscribeOn(scheduler).compose(new BundleableListTransformer<Playlist>(BundleableCompare.<Playlist>func(args.getString(SORTORDER)))).subscribe(subscriber);
}

Output:
         }
-    }).subscribeOn(scheduler).compose(new BundleableListTransformer<Playlist>(BundleableCompare.<Playlist>func(args.getString(SORTORDER)))).subscribe(subscriber);
+    }).subscribeOn(scheduler).compose(new BundleableListTransformer<Playlist>(BundleableCompare.<Playlist>func(args.getString(Extras.SORTORDER)))).subscribe(subscriber);
 }


Input:
public Cursor queryAggregationSuggestions(SQLiteQueryBuilder qb, String[] projection, long contactId, int maxSuggestions, String filter, ArrayList<AggregationSuggestionParameter> parameters) {
    final SQLiteDatabase db = mDbHelper.getReadableDatabase();
    List<MatchScore> bestMatches = findMatchingContacts(db, contactId, parameters);
    return queryMatchingContacts(qb, db, contactId, projection, bestMatches, maxSuggestions, filter);
}

Output:
     final SQLiteDatabase db = mDbHelper.getReadableDatabase();
-    List<MatchScore> bestMatches = findMatchingContacts(db, contactId, parameters);
-    return queryMatchingContacts(qb, db, contactId, projection, bestMatches, maxSuggestions, filter);
+    db.beginTransaction();
+    try {
+        List<MatchScore> bestMatches = findMatchingContacts(db, contactId, parameters);
+        return queryMatchingContacts(qb, db, projection, bestMatches, maxSuggestions, filter);
+    } finally {
+        db.endTransaction();
+    }
 }


Input:
public void weakSchemaCorrectnessCheck(SchemaFactory sf) {
    SAXSource[] sources = new SAXSource[getRootDocuments().size()];
    int i = 0;
    for (String systemId : getRootDocuments()) {
        sources[i] = createSAXSource(systemId);
        try {
            sources[i].getXMLReader().setFeature("String_Node_Str", true);
        } catch (SAXException e) {
            throw new AssertionError(e);
        }
        i++;
    }
    try {
        sf.newSchema(sources);
    } catch (SAXException e) {
    }
}

Output:
 public void weakSchemaCorrectnessCheck(SchemaFactory sf) {
-    SAXSource[] sources = new SAXSource[getRootDocuments().size()];
-    int i = 0;
+    List<SAXSource> sources = new ArrayList<SAXSource>();
     for (String systemId : getRootDocuments()) {


Input:
public YamlNode removeChild(YamlNode node) {
    if (isScalar() || node.getParent() != this) {
        return null;
    }
    if (!this.resolved) {
        try {
            getChildrenList();
        } catch (YamlException e) {
            this.manager.getLogger().stackTrace(e);
            return null;
        }
    }
    if (isList()) {
        this.listCache.remove(node);
    } else {
        this.mapCache.remove(node.getName());
    }
    node.setParent(null);
    return node;
}

Output:
     if (!this.resolved) {
-        try {
-            getChildrenList();
-        } catch (YamlException e) {
-            this.manager.getLogger().stackTrace(e);
-            return null;
-        }
+        throw new IllegalStateException("String_Node_Str");
     }