Input:
public void editIdeaDialog() {
    mEditIdeaDialog = new LovelyCustomDialog(MainActivity.getInstance(), R.style.EditTextTintTheme).setView(R.layout.new_idea_form).setTopColor(mPrimaryColor).setIcon(R.drawable.ic_edit).setListener(R.id.doneButton, new View.OnClickListener() {

        public void onClick(View v) {
            sendEditIdea();
        }
    }).configureView(new LovelyCustomDialog.ViewConfigurator() {
        public void configureView(View v) {
            TextView title = (TextView) v.findViewById(R.id.idea_dialog_title);
            Button doneButton = (Button) v.findViewById(R.id.doneButton);
            mDoLater = (Switch) v.findViewById(R.id.doLater);
            mRadioGroup = (RadioGroup) v.findViewById(R.id.radioGroup);
            mIdeaField = (EditText) v.findViewById(R.id.editText);
            mNoteField = (EditText) v.findViewById(R.id.editNote);
            title.setText(R.string.edit_idea);
            doneButton.setText(R.string.edit);
            mError = (TextView) v.findViewById(R.id.new_error_message);
            mIdeaField.addTextChangedListener(new HideErrorOnTextChanged());
            mIdeaField.setOnEditorActionListener(ideaFieldListener);
            mNoteField.setOnEditorActionListener(noteFieldListener);
            mIdeaField.setOnFocusChangeListener(RecyclerOnClickListener.this);
            mNoteField.setOnFocusChangeListener(RecyclerOnClickListener.this);
            String ideaText = mDbHelper.getTextById(mIdRecycler);
            mIdeaField.append(ideaText);
            mNoteField.setText(mDbHelper.getNoteById(mIdRecycler));
            int fromTab = mDbHelper.getTabById(mIdRecycler);
            if (fromTab == 2)
                mDoLater.toggle();
            RadioButton radio = null;
            switch(mPriority) {
                case 1:
                    radio = (RadioButton) v.findViewById(R.id.radioButton1);
                    break;
                case 2:
                    radio = (RadioButton) v.findViewById(R.id.radioButton2);
                    break;
                case 3:
                    radio = (RadioButton) v.findViewById(R.id.radioButton3);
                    break;
            }
            radio.setChecked(true);
        }
    }).show();
    if (mNoteField.requestFocus() && mIdeaField.requestFocus()) {
        mEditIdeaDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
    }
}

Output:
 public void editIdeaDialog() {
-    mEditIdeaDialog = new LovelyCustomDialog(MainActivity.getInstance(), R.style.EditTextTintTheme).setView(R.layout.new_idea_form).setTopColor(mPrimaryColor).setIcon(R.drawable.ic_edit).setListener(R.id.doneButton, new View.OnClickListener() {
+    mEditIdeaDialog = new LovelyCustomDialog(context, mDarkTheme ? R.style.EditTextTintThemeDark : R.style.EditTextTintTheme).setView(R.layout.new_idea_form).setTopColor(mPrimaryColor).setIcon(R.drawable.ic_edit).setListener(R.id.doneButton, new View.OnClickListener() {


Input:
private void _sendAbsentToAllUnknownOutputsOf(Actor actor) throws IllegalActionException {
    if ((!_isNonStrict(actor)) || (!_isFinishedFiring(actor))) {
        _debug("String_Node_Str", "String_Node_Str", _getNameOf(actor));
        Iterator outputPorts = actor.outputPortList().iterator();
        while (outputPorts.hasNext()) {
            IOPort outputPort = (IOPort) outputPorts.next();
            for (int j = 0; j < outputPort.getWidth(); j++) {
                if (!outputPort.isKnown(j))
                    outputPort.sendAbsent(j);
            }
        }
    }
}

Output:
 private void _sendAbsentToAllUnknownOutputsOf(Actor actor) throws IllegalActionException {
-    if ((!_isNonStrict(actor)) || (!_isFinishedFiring(actor))) {
+    if ((!_isNonStrict(actor)) && (!_isFinishedFiring(actor))) {
         _debug("String_Node_Str", "String_Node_Str", _getNameOf(actor));


Input:
private void checkRequests() {
    final String method = "String_Node_Str";
    final long currentTime = System.currentTimeMillis();
    for (int i = 0; i < requests.size(); i++) {
        Request request = requests.get(i);
        if (request.getTimeoutTime() > currentTime) {
            continue;
        }
        long activeTime = request.getTimeoutTime() - request.startTime;
        if (request.cancelled) {
            if (LOG.isWarnEnabled()) {
                LOG.warn(method, "String_Node_Str" + request.requestId + "String_Node_Str");
            }
            requests.remove(i);
            requestQueue.terminateRequest(request.requestId);
        } else {
            if (LOG.isWarnEnabled()) {
                LOG.warn(method, "String_Node_Str" + request.requestId + "String_Node_Str" + activeTime + "String_Node_Str");
            }
            request.cancelled = true;
            requestQueue.cancelRequest(request.requestId);
        }
    }
}

Output:
     final long currentTime = System.currentTimeMillis();
-    for (int i = 0; i < requests.size(); i++) {
-        Request request = requests.get(i);
+    for (Iterator<Request> i = requests.iterator(); i.hasNext(); ) {
+        Request request = i.next();
         if (request.getTimeoutTime() > currentTime) {


Input:
protected void additionalButtonClickAction(int scoreIndex, Genotype<T> individual) {
    if (arrayPlayer != null) {
        arrayPlayer.stopPlayback();
    }
    if (chosen[scoreIndex]) {
        Network phenotype = individual.getPhenotype();
        double[] amplitude = SoundFromCPPNUtil.amplitudeRemixer(phenotype, WAVDoubleArray, Parameters.parameters.integerParameter("String_Node_Str"), playBackRate, inputMultipliers);
        arrayPlayer = PlayDoubleArray.playDoubleArray(format, amplitude);
    }
}

Output:
         Network phenotype = individual.getPhenotype();
-        double[] amplitude = SoundFromCPPNUtil.amplitudeRemixer(phenotype, WAVDoubleArray, Parameters.parameters.integerParameter("String_Node_Str"), playBackRate, inputMultipliers);
-        arrayPlayer = PlayDoubleArray.playDoubleArray(format, amplitude);
+        double[] amplitude = SoundFromCPPNUtil.amplitudeRemixer(phenotype, WAVDoubleArray, Parameters.parameters.integerParameter("String_Node_Str"), FREQUENCY_DEFAULT, inputMultipliers);
+        arrayPlayer = PlayDoubleArray.playDoubleArray(amplitude);
     }


Input:
private void removeAllRows() throws SQLException {
    PageBtree root = getPage(rootPageId);
    store.logUndo(root, root.data);
    root.freeChildren();
    root = PageBtreeLeaf.create(this, rootPageId, PageBtree.ROOT);
    store.removeRecord(rootPageId);
    store.updateRecord(root);
    rowCount = 0;
}

Output:
     store.removeRecord(rootPageId);
-    store.updateRecord(root);
+    store.update(root);
     rowCount = 0;


Input:
public List<DeploymentPolicy> retrieveDeploymentPolicies() {
    List<DeploymentPolicy> depPolicyList = new ArrayList<DeploymentPolicy>();
    RegistryManager registryManager = RegistryManager.getInstance();
    String[] depPolicyResourceList = (String[]) registryManager.retrieve(AutoScalerConstants.AUTOSCALER_RESOURCE + AutoScalerConstants.DEPLOYMENT_POLICY_RESOURCE);
    if (depPolicyResourceList != null) {
        DeploymentPolicy depPolicy;
        for (String resourcePath : depPolicyResourceList) {
            Object serializedObj = registryManager.retrieve(resourcePath);
            if (serializedObj != null) {
                try {
                    Object dataObj = Deserializer.deserializeFromByteArray((byte[]) serializedObj);
                    if (dataObj instanceof DeploymentPolicy) {
                        depPolicy = (DeploymentPolicy) dataObj;
                        if (log.isDebugEnabled()) {
                            log.debug(String.format("String_Node_Str", depPolicy.getId(), depPolicy.getAllPartitions()));
                        }
                        depPolicyList.add(depPolicy);
                    } else {
                        return null;
                    }
                } catch (Exception e) {
                    String msg = "String_Node_Str";
                    log.warn(msg, e);
                }
            }
        }
    }
    return depPolicyList;
}

Output:
                         if (log.isDebugEnabled()) {
-                            log.debug(String.format("String_Node_Str", depPolicy.getId(), depPolicy.getAllPartitions()));
+                            log.debug(depPolicy.toString());
                         }


Input:
public static boolean containsTimeMirror(IAggregationResultSet rs, int index) {
    for (int i = index; i < rs.getLevelCount(); i++) {
        if (isTimeMirror(rs, i))
            return true;
    }
    return false;
}

Output:
     for (int i = index; i < rs.getLevelCount(); i++) {
-        if (isTimeMirror(rs, i))
+        if (isTimeMirror(rs, i, service))
             return true;


Input:
private Socket createSocket(InetSocketAddress socketAddress) throws IOException {
    Socket socket = new Socket();
    socket.connect(socketAddress);
    socket.setSoTimeout(3000);
    return socket;
}

Output:
 private Socket createSocket(InetSocketAddress socketAddress) throws IOException {
-    Socket socket = new Socket();
-    socket.connect(socketAddress);
-    socket.setSoTimeout(3000);
+    final Socket socket = new Socket();
+    boolean success = false;
+    try {
+        socket.setSoTimeout(3000);
+        socket.connect(socketAddress);
+        success = true;
+    } finally {
+        if (!success) {
+            IOUtils.closeQuietly(socket);
+        }
+    }
     return socket;


Input:
public org.hl7.fhir.dstu2.model.Quantity convertQuantity(org.hl7.fhir.dstu3.model.Quantity src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.Quantity tgt = new org.hl7.fhir.dstu2.model.Quantity();
    copyElement(src, tgt);
    tgt.setValue(src.getValue());
    tgt.setComparator(convertQuantityComparator(src.getComparator()));
    tgt.setUnit(src.getUnit());
    tgt.setSystem(src.getSystem());
    tgt.setCode(src.getCode());
    return tgt;
}

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


Input:
public void messageArrived(String topicName, MqttMessage message) throws Exception {
    TextMessage receivedMessage = new ActiveMQTextMessage();
    if (log.isDebugEnabled()) {
        log.debug(String.format("String_Node_Str"));
    }
    receivedMessage.setText(new String(message.getPayload()));
    receivedMessage.setStringProperty(Constants.EVENT_CLASS_NAME, Util.getEventNameForTopic(topicName));
    try {
        if (log.isDebugEnabled()) {
            log.debug(String.format("String_Node_Str", ((TextMessage) message).getText()));
        }
        messageQueue.add(receivedMessage);
    } catch (JMSException e) {
        log.error(e.getMessage(), e);
    }
}

Output:
         if (log.isDebugEnabled()) {
-            log.debug(String.format("String_Node_Str", ((TextMessage) message).getText()));
+            log.debug(String.format("String_Node_Str", receivedMessage.getText()));
         }


Input:
public static String formatValue(final BigInteger value, final String plusSign, final String minusSign) {
    final boolean negative = value.compareTo(BigInteger.ZERO) < 0;
    final BigInteger absValue = value.abs();
    final String sign = negative ? minusSign : plusSign;
    final int coins = absValue.divide(Utils.COIN).intValue();
    final int cents = absValue.remainder(Utils.COIN).intValue();
    if (cents % 1000000 == 0)
        return String.format(Locale.US, "String_Node_Str", sign, coins, cents / 1000000);
    else if (cents % 10000 == 0)
        return String.format(Locale.US, "String_Node_Str", sign, coins, cents / 10000);
    else
        return String.format(Locale.US, "String_Node_Str", sign, coins, cents);
}

Output:
     final int cents = absValue.remainder(Utils.COIN).intValue();
-    if (cents % 1000000 == 0)
+    if (cents % 1000000 == 0 || precision <= 2)
         return String.format(Locale.US, "String_Node_Str", sign, coins, cents / 1000000);


Input:
public String printCommandFields() {
    final StringBuilder commandBuilder = new StringBuilder();
    for (String commandField : commandFields) {
        commandBuilder.append(commandField).append("String_Node_Str");
    }
    return commandBuilder.toString();
}

Output:
     final StringBuilder commandBuilder = new StringBuilder();
-    for (String commandField : commandFields) {
+    for (final String commandField : commandFields) {
         commandBuilder.append(commandField).append("String_Node_Str");


Input:
public XYSeries getSeries(Comparable key) {
    if (key == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    Iterator iterator = this.data.iterator();
    while (iterator.hasNext()) {
        XYSeries series = (XYSeries) iterator.next();
        if (key.equals(series.getKey())) {
            return series;
        }
    }
    throw new UnknownKeyException("String_Node_Str" + key);
}

Output:
 public XYSeries getSeries(Comparable key) {
-    if (key == null) {
-        throw new IllegalArgumentException("String_Node_Str");
-    }
-    Iterator iterator = this.data.iterator();
-    while (iterator.hasNext()) {
-        XYSeries series = (XYSeries) iterator.next();
+    ParamChecks.nullNotPermitted(key, "String_Node_Str");
+    for (XYSeries series : this.data) {
         if (key.equals(series.getKey())) {


Input:
public JsonResult<ClientBo> saveForUpdate(ClientBo clientBo) {
    if (clientBo.getId() == null) {
        return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), getMessage("String_Node_Str"));
    }
    if (clientService.findExistClientByName(clientBo.getName())) {
        return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), getMessage("String_Node_Str"));
    }
    clientService.save(clientBo);
    return get(clientBo.getId());
}

Output:
     }
-    if (clientService.findExistClientByName(clientBo.getName())) {
-        return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), getMessage("String_Node_Str"));
+    if (clientService.findExistClientName(clientBo.getName())) {
+        if (clientService.findExistClientByName(clientBo.getName()).getId() == clientBo.getId()) {
+            clientService.save(clientBo);
+        } else {
+            return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), getMessage("String_Node_Str"));
+        }
+    } else {
+        clientService.save(clientBo);
     }


Input:
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
    Adapter adapter = mContactsLv.getAdapter();
    if ((null != adapter) && adapter.getCount() > 0) {
        Contacts contacts = (Contacts) adapter.getItem(firstVisibleItem);
        char firstChar = contacts.getSortKey().charAt(0);
        mQuickAlphabeticBar.setCurrentSelectChar(firstChar);
    }
}

Output:
     if ((null != adapter) && adapter.getCount() > 0) {
-        Contacts contacts = (Contacts) adapter.getItem(firstVisibleItem);
-        char firstChar = contacts.getSortKey().charAt(0);
-        mQuickAlphabeticBar.setCurrentSelectChar(firstChar);
+        currentIndex = ((firstVisibleItem + visibleItemCount) < totalItemCount) ? (firstVisibleItem) : (totalItemCount - 1);
+        Contacts contacts = (Contacts) adapter.getItem(currentIndex);
+        char currentSelectChar = contacts.getSortKey().charAt(0);
+        mQuickAlphabeticBar.setCurrentSelectChar(currentSelectChar);
     }


Input:
private void handleSendingEnergy() {
    int energyStored = getEnergyStored();
    for (EnumFacing facing : EnumFacing.VALUES) {
        BlockPos pos = getPos().offset(facing);
        TileEntity te = getWorld().getTileEntity(pos);
        EnumFacing opposite = facing.getOpposite();
        if (EnergyTools.isEnergyTE(te) || (te != null && te.hasCapability(CapabilityEnergy.ENERGY, opposite))) {
            int rfToGive = CoalGeneratorConfiguration.SENDPERTICK <= energyStored ? CoalGeneratorConfiguration.SENDPERTICK : energyStored;
            int received;
            if (RFTools.redstoneflux && RedstoneFluxCompatibility.isEnergyConnection(te)) {
                if (RedstoneFluxCompatibility.canConnectEnergy(te, opposite)) {
                    received = EnergyTools.receiveEnergy(te, opposite, rfToGive);
                } else {
                    received = 0;
                }
            } else {
                received = EnergyTools.receiveEnergy(te, opposite, rfToGive);
            }
            energyStored -= storage.extractEnergy(received, false);
            if (energyStored <= 0) {
                break;
            }
        }
    }
}

Output:
                 if (RedstoneFluxCompatibility.canConnectEnergy(te, opposite)) {
-                    received = EnergyTools.receiveEnergy(te, opposite, rfToGive);
+                    received = (int) EnergyTools.receiveEnergy(te, opposite, rfToGive);
                 } else {


Input:
public boolean isReadOnly() throws SQLException {
    return getConnection().isReadOnly();
}

Output:
 public boolean isReadOnly() throws SQLException {
-    return getConnection().isReadOnly();
+    return getDelegate().isReadOnly();
 }


Input:
public String toString() {
    try {
        StringBuffer sb = new StringBuffer();
        String from = Integer.toString(overallPosition + 1);
        String to = Integer.toString(overallPosition + results.size());
        String of = Integer.toString(total);
        sb.append("String_Node_Str");
        sb.append("String_Node_Str" + from + "String_Node_Str" + to + "String_Node_Str" + of + "String_Node_Str");
        sb.append("String_Node_Str" + browseIndex.getName() + "String_Node_Str" + browseIndex.getDataType() + "String_Node_Str" + browseIndex.getDisplayType() + "String_Node_Str");
        sb.append("String_Node_Str");
        String container = "String_Node_Str";
        DSpaceObject theContainer = null;
        if (inCollection()) {
            container = "String_Node_Str";
            theContainer = this.collection;
        } else if (inCommunity()) {
            container = "String_Node_Str";
            theContainer = this.community;
        }
        String containerID = "String_Node_Str";
        if (theContainer != null) {
            containerID = Integer.toString(theContainer.getID()) + "String_Node_Str" + theContainer.getHandle() + "String_Node_Str";
        }
        sb.append("String_Node_Str" + container + "String_Node_Str" + containerID);
        sb.append("String_Node_Str");
        ItemListConfig config = new ItemListConfig();
        if (browseIndex.isItemIndex()) {
            sb.append("String_Node_Str" + Integer.toString(config.numCols()) + "String_Node_Str");
            for (int k = 1; k <= config.numCols(); k++) {
                if (k > 1) {
                    sb.append("String_Node_Str");
                }
                String[] meta = config.getMetadata(k);
                sb.append(meta[0] + "String_Node_Str" + meta[1] + "String_Node_Str" + meta[2]);
            }
            if (value != null) {
                sb.append("String_Node_Str" + value);
            }
            if (isStartsWith()) {
                sb.append("String_Node_Str" + focus);
            } else if (hasFocus()) {
                sb.append("String_Node_Str" + focus);
            }
        } else if (browseIndex.isMetadataIndex()) {
            sb.append("String_Node_Str" + browseIndex.getMetadata());
            if (isStartsWith()) {
                sb.append("String_Node_Str" + focus);
            } else if (hasFocus()) {
                sb.append("String_Node_Str" + focus);
            }
        }
        sb.append("String_Node_Str");
        String direction = (ascending ? "String_Node_Str" : "String_Node_Str");
        sb.append("String_Node_Str" + sortOption.getMetadata() + "String_Node_Str" + direction + "String_Node_Str" + Integer.toString(sortOption.getNumber()) + "String_Node_Str");
        sb.append("String_Node_Str");
        if (browseIndex.isMetadataIndex() && !isSecondLevel()) {
            sb.append(valueListingString());
        } else if (browseIndex.isItemIndex() || isSecondLevel()) {
            sb.append(fullListingString(config));
        }
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        if (hasNextPage()) {
            if (browseIndex.isMetadataIndex() && !isSecondLevel()) {
                sb.append(this.nextValue);
            } else if (browseIndex.isItemIndex() || isSecondLevel()) {
                sb.append("String_Node_Str" + Integer.toString(this.nextItem));
            }
        } else {
            sb.append("String_Node_Str");
        }
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        if (hasPrevPage()) {
            if (browseIndex.isMetadataIndex() && !isSecondLevel()) {
                sb.append(this.prevValue);
            } else if (browseIndex.isItemIndex() || isSecondLevel()) {
                sb.append("String_Node_Str" + Integer.toString(this.prevItem));
            }
        } else {
            sb.append("String_Node_Str");
        }
        sb.append("String_Node_Str");
        return sb.toString();
    } catch (SQLException e) {
        return e.getMessage();
    } catch (BrowseException e) {
        return e.getMessage();
    }
}

Output:
         if (hasNextPage()) {
-            if (browseIndex.isMetadataIndex() && !isSecondLevel()) {
-                sb.append(this.nextValue);
-            } else if (browseIndex.isItemIndex() || isSecondLevel()) {
-                sb.append("String_Node_Str" + Integer.toString(this.nextItem));
-            }
+            sb.append("String_Node_Str" + Integer.toString(this.nextOffset));
         } else {


Input:
public int getScore() {
    load(CHAMPION_MASTERY_SCORE_LOAD_GROUP);
    return coreData.getScore();
}

Output:
 public int getScore() {
-    load(CHAMPION_MASTERY_SCORE_LOAD_GROUP);
+    if (coreData.getScore() == 0) {
+        load(CHAMPION_MASTERY_SCORE_LOAD_GROUP);
+    }
     return coreData.getScore();


Input:
public boolean containsKey(Data dataKey) {
    checkIfLoaded();
    Record record = records.get(dataKey);
    if (record == null) {
        if (mapContainer.getStore() != null) {
            Object value = mapContainer.getStore().load(mapService.toObject(dataKey));
            if (value != null) {
                record = mapService.createRecord(name, dataKey, value, -1);
                records.put(dataKey, record);
                updateSizeEstimator(calculateRecordSize(record));
            }
        }
    }
    boolean contains = record != null;
    if (contains) {
        accessRecord(record);
    }
    return contains;
}

Output:
             if (value != null) {
-                record = mapService.createRecord(name, dataKey, value, -1);
+                record = mapService.createRecord(name, dataKey, value, DEFAULT_TTL);
                 records.put(dataKey, record);


Input:
public int compare(Description concept1, Description concept2) {
    if (concept1 instanceof Nothing) {
        if (concept2 instanceof Nothing)
            return 0;
        else
            return -1;
    } else if (concept1 instanceof NamedClass) {
        if (concept2 instanceof Nothing)
            return 1;
        else if (concept2 instanceof NamedClass)
            return ((NamedClass) concept1).getName().compareTo(((NamedClass) concept2).getName());
        else
            return -1;
    } else if (concept1 instanceof BooleanValueRestriction) {
        if (concept2 instanceof Nothing || concept2 instanceof NamedClass) {
            return 1;
        } else if (concept2 instanceof BooleanValueRestriction) {
            int cmp = rc.compare(((BooleanValueRestriction) concept1).getRestrictedPropertyExpresssion(), ((BooleanValueRestriction) concept2).getRestrictedPropertyExpresssion());
            if (cmp == 0) {
                boolean val1 = ((BooleanValueRestriction) concept1).getBooleanValue();
                boolean val2 = ((BooleanValueRestriction) concept2).getBooleanValue();
                if (val1) {
                    if (val2)
                        return 0;
                    else
                        return 1;
                } else {
                    if (val2)
                        return -1;
                    else
                        return 0;
                }
            } else
                return cmp;
        } else
            return -1;
    } else if (concept1 instanceof DatatypeSomeRestriction) {
        if (concept2 instanceof Nothing || concept2 instanceof NamedClass || concept2 instanceof BooleanValueRestriction) {
            return 1;
        } else if (concept2 instanceof DatatypeSomeRestriction) {
            DatatypeSomeRestriction dsr = (DatatypeSomeRestriction) concept1;
            DatatypeProperty dp = (DatatypeProperty) dsr.getRestrictedPropertyExpression();
            DatatypeSomeRestriction dsr2 = (DatatypeSomeRestriction) concept2;
            DatatypeProperty dp2 = (DatatypeProperty) dsr2.getRestrictedPropertyExpression();
            int cmp = rc.compare(dp, dp2);
            if (cmp == 0) {
                SimpleDoubleDataRange dr = (SimpleDoubleDataRange) dsr.getDataRange();
                SimpleDoubleDataRange dr2 = (SimpleDoubleDataRange) dsr2.getDataRange();
                if ((dr instanceof DoubleMaxValue && dr2 instanceof DoubleMaxValue) || (dr instanceof DoubleMinValue && dr2 instanceof DoubleMinValue)) {
                    double val1 = dr.getValue();
                    double val2 = dr2.getValue();
                    if (val1 > val2)
                        return 1;
                    else if (val1 == val2)
                        return 0;
                    else
                        return -1;
                } else if (dr instanceof DoubleMaxValue)
                    return 1;
                else
                    return -1;
            } else
                return cmp;
        } else
            return -1;
    } else if (concept1 instanceof Thing) {
        if (concept2 instanceof Nothing || concept2 instanceof NamedClass || concept2 instanceof BooleanValueRestriction || concept2 instanceof DatatypeSomeRestriction)
            return 1;
        else if (concept2 instanceof Thing)
            return 0;
        else
            return -1;
    } else if (concept1 instanceof Negation) {
        if (concept2.getChildren().size() < 1)
            return 1;
        else if (concept2 instanceof Negation)
            return compare(concept1.getChild(0), concept2.getChild(0));
        else
            return -1;
    } else if (concept1 instanceof ObjectSomeRestriction) {
        if (concept2.getChildren().size() < 1 || concept2 instanceof Negation)
            return 1;
        else if (concept2 instanceof ObjectSomeRestriction) {
            int roleCompare = rc.compare(((ObjectQuantorRestriction) concept1).getRole(), ((ObjectQuantorRestriction) concept2).getRole());
            if (roleCompare == 0)
                return compare(concept1.getChild(0), concept2.getChild(0));
            else
                return roleCompare;
        } else
            return -1;
    } else if (concept1 instanceof ObjectAllRestriction) {
        if (concept2.getChildren().size() < 1 || concept2 instanceof Negation || concept2 instanceof ObjectSomeRestriction)
            return 1;
        else if (concept2 instanceof ObjectAllRestriction) {
            int roleCompare = rc.compare(((ObjectQuantorRestriction) concept1).getRole(), ((ObjectQuantorRestriction) concept2).getRole());
            if (roleCompare == 0)
                return compare(concept1.getChild(0), concept2.getChild(0));
            else
                return roleCompare;
        } else
            return -1;
    } else if (concept1 instanceof ObjectValueRestriction) {
        if (concept2.getChildren().size() < 1 || concept2 instanceof Negation || concept2 instanceof ObjectSomeRestriction || concept2 instanceof ObjectAllRestriction)
            return 1;
        else if (concept2 instanceof ObjectValueRestriction) {
            int roleCompare = rc.compare(((ObjectValueRestriction) concept1).getRestrictedPropertyExpression(), ((ObjectQuantorRestriction) concept2).getRestrictedPropertyExpression());
            if (roleCompare == 0) {
                Individual value1 = ((ObjectValueRestriction) concept1).getIndividual();
                Individual value2 = ((ObjectValueRestriction) concept2).getIndividual();
                return value1.compareTo(value2);
            } else {
                return roleCompare;
            }
        } else
            return -1;
    } else if (concept1 instanceof ObjectMinCardinalityRestriction) {
        if (concept2.getChildren().size() < 1 || concept2 instanceof Negation || concept2 instanceof ObjectQuantorRestriction || concept2 instanceof ObjectValueRestriction)
            return 1;
        else if (concept2 instanceof ObjectMinCardinalityRestriction) {
            int roleCompare = rc.compare(((ObjectCardinalityRestriction) concept1).getRole(), ((ObjectCardinalityRestriction) concept2).getRole());
            if (roleCompare == 0) {
                Integer number1 = ((ObjectCardinalityRestriction) concept1).getNumber();
                Integer number2 = ((ObjectCardinalityRestriction) concept2).getNumber();
                int numberCompare = number1.compareTo(number2);
                if (numberCompare == 0)
                    return compare(concept1.getChild(0), concept2.getChild(0));
                else
                    return numberCompare;
            } else
                return roleCompare;
        } else
            return -1;
    } else if (concept1 instanceof ObjectMaxCardinalityRestriction) {
        if (concept2.getChildren().size() < 1 || concept2 instanceof Negation || concept2 instanceof ObjectQuantorRestriction || concept2 instanceof ObjectValueRestriction || concept2 instanceof ObjectMinCardinalityRestriction)
            return 1;
        else if (concept2 instanceof ObjectMaxCardinalityRestriction) {
            int roleCompare = rc.compare(((ObjectCardinalityRestriction) concept1).getRole(), ((ObjectCardinalityRestriction) concept2).getRole());
            if (roleCompare == 0) {
                Integer number1 = ((ObjectCardinalityRestriction) concept1).getNumber();
                Integer number2 = ((ObjectCardinalityRestriction) concept2).getNumber();
                int numberCompare = number1.compareTo(number2);
                if (numberCompare == 0)
                    return compare(concept1.getChild(0), concept2.getChild(0));
                else
                    return numberCompare;
            } else
                return roleCompare;
        } else
            return -1;
    } else if (concept1 instanceof Intersection) {
        if (concept2.getChildren().size() < 2)
            return 1;
        else if (concept2 instanceof Intersection) {
            int nrOfChildrenConcept1 = concept1.getChildren().size();
            int nrOfChildrenConcept2 = concept2.getChildren().size();
            if (nrOfChildrenConcept1 > nrOfChildrenConcept2)
                return 1;
            else if (nrOfChildrenConcept1 == nrOfChildrenConcept2) {
                for (int i = 0; i < nrOfChildrenConcept1; i++) {
                    int compareValue = compare(concept1.getChild(i), concept2.getChild(i));
                    if (compareValue > 0)
                        return 1;
                    else if (compareValue < 0)
                        return -1;
                }
                return 0;
            } else
                return -1;
        } else
            return -1;
    } else if (concept1 instanceof Union) {
        if (concept2.getChildren().size() < 2 || concept2 instanceof Intersection)
            return 1;
        else if (concept2 instanceof Union) {
            int nrOfChildrenConcept1 = concept1.getChildren().size();
            int nrOfChildrenConcept2 = concept2.getChildren().size();
            if (nrOfChildrenConcept1 > nrOfChildrenConcept2)
                return 1;
            else if (nrOfChildrenConcept1 == nrOfChildrenConcept2) {
                for (int i = 0; i < nrOfChildrenConcept1; i++) {
                    int compareValue = compare(concept1.getChild(i), concept2.getChild(i));
                    if (compareValue > 0)
                        return 1;
                    else if (compareValue < 0)
                        return -1;
                }
                return 0;
            } else
                return -1;
        } else
            return -1;
    } else
        throw new RuntimeException(concept1.toString());
}

Output:
     } else if (concept1 instanceof Thing) {
-        if (concept2 instanceof Nothing || concept2 instanceof NamedClass || concept2 instanceof BooleanValueRestriction || concept2 instanceof DatatypeSomeRestriction)
+        if (concept2 instanceof Nothing || concept2 instanceof NamedClass || concept2 instanceof BooleanValueRestriction || concept2 instanceof DatatypeSomeRestriction || concept2 instanceof ObjectValueRestriction)
             return 1;


Input:
public String toString() {
    final List<String> list = stack.get();
    return list == null ? "String_Node_Str" : list.toString();
}

Output:
 public String toString() {
-    final List<String> list = stack.get();
-    return list == null ? "String_Node_Str" : list.toString();
+    final MutableThreadContextStack values = stack.get();
+    return values == null ? "String_Node_Str" : values.toString();
 }


Input:
public ProjectVersion saveNewVersion(String newVersionLabel, ProjectVersion original) {
    Map<String, String> oldToNewUUIDMapping = new HashMap<>();
    ProjectVersion newVersion = copyWithNewUUID(oldToNewUUIDMapping, original);
    newVersion.setVersionLabel(newVersionLabel);
    newVersion.setCreateTime(new Date());
    newVersion.setOrigVersionId(original.getId());
    save(newVersion);
    List<ModelName> models = findModelsInProject(original.getId());
    for (ModelName modelName : models) {
        Model newModel = copy(oldToNewUUIDMapping, findModel(modelName.getId()));
        newModel.setProjectVersionId(newVersion.getId());
        save(newModel);
    }
    List<ResourceName> resources = findResourcesInProject(original.getId());
    for (ResourceName resourceName : resources) {
        Resource newResource = copy(oldToNewUUIDMapping, findResource(resourceName.getId()));
        newResource.setProjectVersionId(newVersion.getId());
        save(newResource);
    }
    List<FlowName> testFlows = findFlowsInProject(original.getId(), true);
    for (FlowName flowName : testFlows) {
        Flow newFlow = copy(oldToNewUUIDMapping, findFlow(flowName.getId()));
        newFlow.setProjectVersionId(newVersion.getId());
        save(newFlow);
    }
    List<FlowName> flows = findFlowsInProject(original.getId(), false);
    for (FlowName flowName : flows) {
        Flow newFlow = copy(oldToNewUUIDMapping, findFlow(flowName.getId()));
        newFlow.setProjectVersionId(newVersion.getId());
        save(newFlow);
    }
    return newVersion;
}

Output:
 public ProjectVersion saveNewVersion(String newVersionLabel, ProjectVersion original) {
-    Map<String, String> oldToNewUUIDMapping = new HashMap<>();
+    Map<String, AbstractObject> oldToNewUUIDMapping = new HashMap<>();
     ProjectVersion newVersion = copyWithNewUUID(oldToNewUUIDMapping, original);


Input:
public boolean onCommand(CommandPerformEvent event) {
    try {
        CommandModule module = this.getModuleFor(event.getCommand());
        if (module == null) {
            ArrayList<CommandModule> dynamicModules = getGroupsMap().get(CommandGroup.DYNAMIC);
            if (dynamicModules != null && !dynamicModules.isEmpty()) {
                module = matchModule(dynamicModules, event.getCommand());
            }
        }
        if (module != null) {
            ChannelConfiguration channelConfiguration = Nexus.getInstance().getChannelConfiguration();
            if (channelConfiguration.getChannel("String_Node_Str").isDisabled(module.info().command())) {
                return true;
            }
            if (!event.isInPrivateMessage() && !Arrays.asList(module.info().groups()).contains(CommandGroup.ADMIN)) {
                if (channelConfiguration.getChannel(event.getChannel().getName()).isDisabled(module.info().command())) {
                    return true;
                }
            }
            if (module.checkPerm(event.getChannel(), event.getSender())) {
                if (module.info().needsChannel() && event.isInPrivateMessage()) {
                    event.respond("String_Node_Str", event.getCommandPrefix() + module.info().command() + "String_Node_Str" + StringUtil.combineSplit(0, event.getArgs(), "String_Node_Str"));
                    return true;
                }
                if (!module.onCommand(event)) {
                    event.errorWithPing("String_Node_Str" + Nexus.getInstance().getConfig().getCommandPrefix() + "String_Node_Str" + formatHelp(module) + "String_Node_Str", Nexus.getInstance().getConfig().getCommandPrefix() + "String_Node_Str" + event.getCommand());
                }
                Nexus.LOGGER.info(event.getSender().getNick() + "String_Node_Str" + (event.isInPrivateMessage() ? "String_Node_Str" : event.getChannel().getName()) + "String_Node_Str" + event.getCommand() + "String_Node_Str" + StringUtil.combineSplit(0, event.getArgs(), "String_Node_Str"));
                return true;
            }
        }
    } catch (Exception e) {
        if (e instanceof GitHubAPIKeyInvalidException) {
            event.errorWithPing(e.getMessage() + "String_Node_Str", Nexus.getInstance().getConfig().getCommandPrefix() + "String_Node_Str");
        } else if (e instanceof DateParseException) {
            event.errorWithPing(e.getMessage());
        } else if (e instanceof GitHubRateLimitExceededException) {
            event.errorWithPing("String_Node_Str");
        } else if (e instanceof GitHubHookNotFoundException) {
            event.errorWithPing(e.getMessage());
        } else if (e instanceof NumberFormatException) {
            event.errorWithPing("String_Node_Str");
        } else {
            if (Nexus.getInstance().getGitHubConfig().getNexusGitHubApiKey().isEmpty()) {
                e.printStackTrace();
                event.errorWithPing("String_Node_Str");
                return true;
            }
            event.errorWithPing("String_Node_Str" + GitHub.getGitHub().createGist(e));
        }
        return true;
    }
    return false;
}

Output:
             }
-            event.errorWithPing("String_Node_Str" + GitHub.getGitHub().createGist(e));
+            try {
+                event.errorWithPing("String_Node_Str" + GitHub.getGitHub().createGist(e));
+            } catch (Exception e1) {
+                event.errorWithPing("String_Node_Str");
+                e.printStackTrace();
+            }
         }


Input:
private void renderPaper(int x, int y, int mouseX, int mouseY) {
    GL11.glDisable(GL11.GL_DEPTH_TEST);
    pageArrows[0].xPosition = x - (guiPageTexWidth * 3 / 10) - 10;
    pageArrows[1].xPosition = x + (guiPageTexWidth * 3 / 10) - 10;
    GL11.glColor4f(1F, 1F, 1F, 1F);
    RenderHelper.disableStandardItemLighting();
    mc.getTextureManager().bindTexture(texPage);
    drawTexturedModalRect(x - (guiPageTexWidth >> 1), y - (guiPageTexHeight >> 1), 0, 0, guiPageTexWidth, guiPageTexHeight);
    if (compendiumFile.hasDiscoveredObject(currentObject)) {
        x = x - (guiPageTexWidth >> 1) + guiPageLeft;
        y = y - (guiPageTexHeight >> 1) + guiPageTop;
        for (Entry<KnowledgeFragment, Boolean> entry : currentObjectPages.get(pageIndex).entrySet()) {
            entry.getKey().onRender(this, x, y, mouseX, mouseY, entry.getValue());
            y += 8 + entry.getKey().getHeight(this, entry.getValue());
        }
        for (int a = 0; a < 2; a++) pageArrows[a].visible = true;
        pageArrows[0].visible = pageIndex > 0;
        pageArrows[1].visible = pageIndex < currentObjectPages.size() - 1;
        x = x + (guiPageTexWidth >> 1) - guiPageLeft;
    }
    for (PurchaseDisplayElement element : purchaseElements) element.render(this, mouseX, mouseY, x);
    if (!currentObject.isBuyable() && !compendiumFile.hasDiscoveredObject(currentObject)) {
        RenderHelper.disableStandardItemLighting();
        String msg = I18n.format("String_Node_Str");
        mc.fontRenderer.drawString(msg, x - (mc.fontRenderer.getStringWidth(msg) >> 1), y - 7, 0x404040);
    }
    GL11.glEnable(GL11.GL_DEPTH_TEST);
}

Output:
     drawTexturedModalRect(x - (guiPageTexWidth >> 1), y - (guiPageTexHeight >> 1), 0, 0, guiPageTexWidth, guiPageTexHeight);
-    if (compendiumFile.hasDiscoveredObject(currentObject)) {
+    if (compendiumFile.isDiscovered(currentObject)) {
         x = x - (guiPageTexWidth >> 1) + guiPageLeft;


Input:
public void startMessage() {
    if (DEBUG)
        log("String_Node_Str");
    currentColumnIO = MessageColumnIO.this;
    r[0] = 0;
    currentIndex[0] = 0;
    if (DEBUG)
        printState();
}

Output:
     r[0] = 0;
-    currentIndex[0] = 0;
+    int numberOfFieldsToVisit = ((GroupColumnIO) currentColumnIO).getChildrenCount();
+    fieldsWritten[0].reset(numberOfFieldsToVisit);
     if (DEBUG)


Input:
private static SimpleDateFormat getAbbrWeekFormat() {
    if (abbrWeekFormat != null)
        return abbrWeekFormat;
    try {
        Locale defaultLocale = Context.enter().getLocale();
        abbrWeekFormat = new SimpleDateFormat("String_Node_Str", defaultLocale);
        return abbrWeekFormat;
    } finally {
        Context.exit();
    }
}

Output:
 private static SimpleDateFormat getAbbrWeekFormat() {
-    if (abbrWeekFormat != null)
-        return abbrWeekFormat;
-    try {
-        Locale defaultLocale = Context.enter().getLocale();
+    if (abbrWeekFormat == null)
         abbrWeekFormat = new SimpleDateFormat("String_Node_Str", defaultLocale);


Input:
void dump(PrintWriter pw, String prefix) {
    pw.print(prefix);
    pw.print("String_Node_Str");
    pw.print(uid);
    pw.print("String_Node_Str");
    pw.print(key.packageName);
    pw.print("String_Node_Str");
    pw.print(key.typeName());
    pw.print("String_Node_Str");
    pw.println(Integer.toHexString(key.flags));
    if (key.activity != null || key.who != null) {
        pw.print(prefix);
        pw.print("String_Node_Str");
        pw.print(key.activity);
        pw.print("String_Node_Str");
        pw.println(key.who);
    }
    if (key.requestCode != 0 || key.requestResolvedType != null) {
        pw.print(prefix);
        pw.print("String_Node_Str");
        pw.print(key.requestCode);
        pw.print("String_Node_Str");
        pw.println(key.requestResolvedType);
    }
    pw.print(prefix);
    pw.print("String_Node_Str");
    pw.println(key.requestIntent.toShortString(true, true));
    if (sent || canceled) {
        pw.print(prefix);
        pw.print("String_Node_Str");
        pw.print(sent);
        pw.print("String_Node_Str");
        pw.println(canceled);
    }
}

Output:
     }
-    pw.print(prefix);
-    pw.print("String_Node_Str");
-    pw.println(key.requestIntent.toShortString(true, true));
+    if (key.requestIntent != null) {
+        pw.print(prefix);
+        pw.print("String_Node_Str");
+        pw.println(key.requestIntent.toShortString(true, true));
+    }
     if (sent || canceled) {


Input:
public void testSlowRecursiveOperation() {
    int partitionThreads = 32;
    int numberOfOperations = 50;
    int recursionDepth = 20;
    Config config = new Config();
    config.setProperty(GroupProperties.PROP_SLOW_OPERATION_DETECTOR_THRESHOLD_MILLIS, "String_Node_Str");
    config.setProperty(GroupProperties.PROP_PARTITION_OPERATION_THREAD_COUNT, String.valueOf(partitionThreads));
    instance = createHazelcastInstance(config);
    List<SlowRecursiveOperation> operations = new ArrayList<SlowRecursiveOperation>(numberOfOperations);
    int partitionCount = getNode(instance).nodeEngine.getPartitionService().getPartitionCount();
    int partitionIndex = 1;
    for (int i = 0; i < numberOfOperations; i++) {
        int partitionId = partitionIndex % partitionCount;
        SlowRecursiveOperation operation = new SlowRecursiveOperation(partitionId, recursionDepth, 3);
        operations.add(operation);
        executeOperation(instance, operation);
        partitionIndex += partitionCount / partitionThreads + 1;
    }
    for (SlowRecursiveOperation operation : operations) {
        operation.await();
    }
    Collection<SlowOperationLog> logs = getSlowOperationLogs(instance);
    assertNumberOfSlowOperationLogs(logs, 1);
    SlowOperationLog firstLog = logs.iterator().next();
    assertTotalInvocations(firstLog, numberOfOperations);
    assertStackTraceContainsClassName(firstLog, "String_Node_Str");
}

Output:
     int partitionThreads = 32;
-    int numberOfOperations = 50;
-    int recursionDepth = 20;
+    int numberOfOperations = 40;
+    int recursionDepth = 15;
     Config config = new Config();


Input:
private void loadImage(String imageUrl) {
    if (TextUtils.isEmpty(imageUrl)) {
        handleImageLoadFailure();
        return;
    }
    if (mIsPrivate) {
        imageUrl = UrlUtils.makeHttps(imageUrl);
    } else {
        Point pt = DisplayUtils.getDisplayPixelSize(this);
        int maxWidth = Math.max(pt.x, pt.y);
        imageUrl = PhotonUtils.getPhotonImageUrl(imageUrl, maxWidth, 0);
    }
    final ProgressBar progress = (ProgressBar) findViewById(R.id.progress);
    progress.setVisibility(View.VISIBLE);
    final WPNetworkImageView imageView = (WPNetworkImageView) findViewById(R.id.image_photo);
    imageView.setImageUrl(imageUrl, ImageType.PHOTO_FULL, new ImageListener() {
        public void onImageLoaded(boolean succeeded) {
            progress.setVisibility(View.GONE);
            if (succeeded) {
                createAttacher(imageView);
            } else {
                handleImageLoadFailure();
            }
        }
    });
}

Output:
     if (mIsPrivate) {
-        imageUrl = UrlUtils.makeHttps(imageUrl);
+        imageUrl = ReaderUtils.getPrivateImageForDisplay(imageUrl, maxWidth, 0);
     } else {


Input:
public void appendSignature(StringBuilder builder) {
    if (this.lowerBound != null) {
        builder.append("String_Node_Str");
        return;
    }
    if (this.upperBound != null) {
        this.upperBound.appendSignature(builder);
    }
}

Output:
 public void appendSignature(StringBuilder builder) {
-    if (this.lowerBound != null) {
-        builder.append("String_Node_Str");
+    if (this.bound != null && this.variance == Variance.COVARIANT) {
+        this.bound.appendSignature(builder);
         return;


Input:
public void processSamples(final TimeCursor timeCursor, final int sampleCount, final SampleOpcode opcode, final Object value) {
    for (int i = 0; i < sampleCount; i++) {
        final DateTime sampleTimestamp = TimelineTimes.dateTimeFromUnixSeconds(timeCursor.getNextTime());
        final long sampleMillis = sampleTimestamp.getMillis();
        if ((startTime == null || (sampleMillis >= startTime.getMillis())) && (endTime == null || (sampleMillis <= endTime.getMillis()))) {
            processOneSample(sampleTimestamp, opcode, value);
        }
    }
}

Output:
     for (int i = 0; i < sampleCount; i++) {
-        final DateTime sampleTimestamp = TimelineTimes.dateTimeFromUnixSeconds(timeCursor.getNextTime());
-        final long sampleMillis = sampleTimestamp.getMillis();
-        if ((startTime == null || (sampleMillis >= startTime.getMillis())) && (endTime == null || (sampleMillis <= endTime.getMillis()))) {
-            processOneSample(sampleTimestamp, opcode, value);
+        final int unixSampleTime = timeCursor.getNextTime();
+        if (unixSampleTime >= unixStartTime && unixSampleTime <= unixEndTime) {
+            processOneSample(TimelineTimes.dateTimeFromUnixSeconds(unixSampleTime), opcode, value);
         }


Input:
private RestResult delegate(RestOperation operation, Uri uri, Object item) {
    switch(operation) {
        case DELETE:
            return databaseDelegate.delete(uri);
        case GET:
            return databaseDelegate.get(uri);
        case POST:
            return databaseDelegate.post(uri, item);
        case PUT:
            return databaseDelegate.put(uri, item);
        default:
            String message = "String_Node_Str" + operation.name();
            return new RestResult(false, message, null);
    }
}

Output:
         case DELETE:
-            return databaseDelegate.delete(uri);
+            return databaseDelegate.delete(uri, itemParser);
         case GET:


Input:
public boolean isMinMax() {
    return !(Double.compare(min, Double.NaN) == 0 || Double.compare(max, Double.NaN) == 0) && Number.class.isAssignableFrom(unPrimitivize(getType()));
}

Output:
 public boolean isMinMax() {
-    return !(Double.compare(min, Double.NaN) == 0 || Double.compare(max, Double.NaN) == 0) && Number.class.isAssignableFrom(unPrimitivize(getType()));
+    return !(Double.compare(min, Double.NaN) == 0 || Double.compare(max, Double.NaN) == 0) && Number.class.isAssignableFrom(getType());
 }


Input:
public URL getFileLink(IFileSpec file) throws Exception {
    int r = new Integer(file.getEndRevision());
    String path = file.getDepotPathString();
    path = path.replace("String_Node_Str", "String_Node_Str");
    String rev = "String_Node_Str" + r;
    return new URL(url.toString() + path + rev);
}

Output:
 public URL getFileLink(IFileSpec file) throws Exception {
-    int r = new Integer(file.getEndRevision());
+    int r = file.getEndRevision();
     String path = file.getDepotPathString();


Input:
public void serialize(ONCRPCBufferWriter writer) {
    write_cap.serialize(writer);
}

Output:
 public void serialize(ONCRPCBufferWriter writer) {
-    write_cap.serialize(writer);
+    write_xcap.serialize(writer);
 }


Input:
protected void initChannel(Channel ch) {
    ch.pipeline().addLast(new LoggingHandler(), new ConnectionStateHandler(), HandshakeHandler.produceLoginHandshake(), new LoginServerCodec(), new MessageDemuxDecoder());
}

Output:
 protected void initChannel(Channel ch) {
-    ch.pipeline().addLast(new LoggingHandler(), new ConnectionStateHandler(), HandshakeHandler.produceLoginHandshake(), new LoginServerCodec(), new MessageDemuxDecoder());
+    ch.pipeline().addLast(new LoggingHandler(), new ConnectionStateHandler(), HandshakeHandler.produceLoginHandshake(encrypted), new LoginServerCodec(), new MessageDemuxDecoder());
 }


Input:
private void calculateBiomes(Map<DimletType, List<Integer>> dimlets, Random random) {
    List<Integer> list = dimlets.get(DimletType.DIMLET_BIOME);
    for (Integer id : list) {
        String biomeName = KnownDimletConfiguration.idToBiome.get(id);
        BiomeManager.BiomeEntry entry = findBiomeEntry(biomeName, BiomeManager.BiomeType.COOL);
        entry = entry != null ? entry : findBiomeEntry(biomeName, BiomeManager.BiomeType.WARM);
        entry = entry != null ? entry : findBiomeEntry(biomeName, BiomeManager.BiomeType.DESERT);
        entry = entry != null ? entry : findBiomeEntry(biomeName, BiomeManager.BiomeType.ICY);
        if (entry != null) {
            biomes.add(entry.biome);
        }
    }
}

Output:
     for (Integer id : list) {
-        String biomeName = KnownDimletConfiguration.idToBiome.get(id);
-        BiomeManager.BiomeEntry entry = findBiomeEntry(biomeName, BiomeManager.BiomeType.COOL);
-        entry = entry != null ? entry : findBiomeEntry(biomeName, BiomeManager.BiomeType.WARM);
-        entry = entry != null ? entry : findBiomeEntry(biomeName, BiomeManager.BiomeType.DESERT);
-        entry = entry != null ? entry : findBiomeEntry(biomeName, BiomeManager.BiomeType.ICY);
-        if (entry != null) {
-            biomes.add(entry.biome);
-        }
+        biomes.add(KnownDimletConfiguration.idToBiome.get(id));
     }


Input:
public void onResponse(Call<Results<Visit>> call, Response<Results<Visit>> response) {
    if (response.isSuccessful()) {
        List<Visit> visits = response.body().getResults();
        VisitDAO visitDAO = new VisitDAO();
        for (Visit visit : visits) {
            long visitId = visitDAO.getVisitsIDByUUID(visit.getUuid());
            if (visitId > 0) {
                visitDAO.updateVisit(visit, visitId, mPatient.getId());
            } else {
                visitDAO.saveVisit(visit, mPatient.getId());
            }
            mPatientVisitsView.setVisitsToDisplay(visits);
        }
        showStartVisitDialog();
    } else {
        ToastUtil.error(response.message());
    }
    mPatientVisitsView.dismissStartVisitDialog();
}

Output:
             }
-            mPatientVisitsView.setVisitsToDisplay(visits);
+            mPatientVisitsView.setVisitsToDisplay(visitDAO.getVisitsByPatientID(mPatient.getId()));
         }


Input:
public boolean addToInventory(ItemStack item) {
    if ((SLOT_INVENTORY_START == -1) || (SLOT_INVENTORY_END == -1))
        return false;
    int extraSlot = extraSlotCheck(item);
    if (extraSlot >= 0) {
        item = moveItemToSlot(item, extraSlot);
    }
    for (int i = SLOT_INVENTORY_START; i <= SLOT_INVENTORY_END; i++) {
        if (slots[i] != null) {
            if (item != null) {
                if ((slots[i].isItemEqual(item)) && (slots[i].stackSize < slots[i].getMaxStackSize()) && (ItemStack.areItemStackTagsEqual(item, slots[i]))) {
                    int avail = slots[i].getMaxStackSize() - slots[i].stackSize;
                    if (avail >= item.stackSize) {
                        slots[i].stackSize += item.stackSize;
                        item = null;
                        return true;
                    } else {
                        item.stackSize -= avail;
                        slots[i].stackSize += avail;
                    }
                }
            }
        }
    }
    if ((item != null) && (item.stackSize > 0)) {
        for (int i = SLOT_INVENTORY_START; i <= SLOT_INVENTORY_END; i++) {
            if (slots[i] == null) {
                if (this.isItemValidForSlot(i, item)) {
                    slots[i] = item;
                    item = null;
                    return true;
                }
            }
        }
    }
    if ((item != null) && (item.stackSize == 0)) {
        item = null;
    }
    if (item != null) {
        dropItem(item);
        item = null;
    }
    return false;
}

Output:
             if (slots[i] == null) {
-                if (this.isItemValidForSlot(i, item)) {
+                if (this.isItemValidForSlot(i, item, true)) {
                     slots[i] = item;


Input:
public void widgetSelected(SelectionEvent e) {
    if (e.getSource().equals(cmbUnits)) {
        getChart().setUnits(LiteralHelper.unitsOfMeasurementSet.getNameByDisplayName(cmbUnits.getText()));
        if (cmbUnits.getSelectionIndex() != 0 && !btnSeriesThickness.getSelection()) {
            txtSeriesThickness.setValue(recalculateUnitDependentValues(txtSeriesThickness.getValue()));
        }
        lblSeriesThickness.setText(new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { LiteralHelper.unitsOfMeasurementSet.getDisplayNameByName(getChart().getUnits()) }));
        sOldUnits = getChart().getUnits();
    } else if (e.getSource().equals(iscColumnCount)) {
        getChart().setGridColumnCount(iscColumnCount.getSelection());
    } else if (e.getSource().equals(txtUnitSpacing)) {
        ((ChartWithAxes) getChart()).setUnitSpacing(txtUnitSpacing.getSelection());
    } else if (e.widget == btnSeriesThickness) {
        if (btnSeriesThickness.getSelection()) {
            getChart().unsetSeriesThickness();
        } else {
            updateToSeriesThickness();
        }
        txtSeriesThickness.setEnabled(!btnSeriesThickness.getSelection());
    } else if (e.widget == btnColumnCount) {
        if (btnColumnCount.getSelection()) {
            getChart().unsetGridColumnCount();
        } else {
            getChart().setGridColumnCount(iscColumnCount.getSelection());
        }
        iscColumnCount.setEnabled(!btnColumnCount.getSelection());
    } else if (e.widget == btnUnitSpacing) {
        if (btnUnitSpacing.getSelection()) {
            ((ChartWithAxes) getChart()).unsetUnitSpacing();
        } else {
            ((ChartWithAxes) getChart()).setUnitSpacing(txtUnitSpacing.getSelection());
        }
        txtUnitSpacing.setEnabled(!btnUnitSpacing.getSelection());
    }
}

Output:
         }
-        lblSeriesThickness.setText(new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { LiteralHelper.unitsOfMeasurementSet.getDisplayNameByName(getChart().getUnits()) }));
-        sOldUnits = getChart().getUnits();
+        lblSeriesThickness.setText(new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { LiteralHelper.unitsOfMeasurementSet.getDisplayNameByName(getUnits()) }));
+        sOldUnits = getUnits();
     } else if (e.getSource().equals(iscColumnCount)) {


Input:
public List<MoveLine> getInvoiceMoveLineListToReconcile(PaymentSchedule paymentSchedule) {
    return MoveLine.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", IAccount.VALIDATED_MOVE, true, IInvoice.CLIENT_SALE, paymentSchedule).fetch();
}

Output:
 public List<MoveLine> getInvoiceMoveLineListToReconcile(PaymentSchedule paymentSchedule) {
-    return MoveLine.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", IAccount.VALIDATED_MOVE, true, IInvoice.CLIENT_SALE, paymentSchedule).fetch();
+    return MoveLine.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", IAccount.VALIDATED_MOVE, true, IInvoice.CLIENT_SALE, paymentSchedule).fetch();
 }


Input:
protected boolean hasAdvancedEditor() {
    if (value instanceof FlowStep) {
        FlowStep flowStep = (FlowStep) value;
        String type = flowStep.getComponent().getType();
        XMLComponentUI definition = context.getUiFactory().getDefinition(type);
        return definition != null && definition.getClassName() != null;
    } else {
        return false;
    }
}

Output:
 protected boolean hasAdvancedEditor() {
-    if (value instanceof FlowStep) {
-        FlowStep flowStep = (FlowStep) value;
+    FlowStep flowStep = null;
+    if (value instanceof List<?>) {
+        List<Object> l = (List<Object>) value;
+        if (l.size() == 1) {
+            if (l.get(0) instanceof FlowStep) {
+                flowStep = (FlowStep) l.get(0);
+            }
+        }
+    }
+    if (flowStep != null) {
         String type = flowStep.getComponent().getType();


Input:
public String get(final WebRequest request, final String key) {
    String result = null;
    Cookie prefCookie = request.getCookie(Constants.PREFS_COOKIE_NAME);
    if (prefCookie != null) {
        Map<String, String> prefs;
        try {
            prefs = getPrefs(new String(Base64.decodeBase64(prefCookie.getValue().getBytes())));
        } catch (IOException e) {
            LOG.error("String_Node_Str" + prefCookie.getValue(), e);
            prefs = new HashMap<String, String>();
        }
        result = prefs.get(key);
    } else {
        LOG.warn("String_Node_Str" + Constants.PREFS_COOKIE_NAME);
    }
    return result;
}

Output:
         } catch (IOException e) {
-            LOG.error("String_Node_Str" + prefCookie.getValue(), e);
+            LOG.error("String_Node_Str", prefCookie.getValue(), e);
             prefs = new HashMap<String, String>();


Input:
private void makeScripts(File directory) {
    ArgumentNotValid.checkNotNull(directory, "String_Node_Str");
    String ext = Constants.UNDERSCORE + name + Constants.SCRIPT_EXTENSION_LINUX;
    File killall = new File(directory, Constants.SCRIPT_NAME_KILL_ALL + ext);
    File install = new File(directory, Constants.SCRIPT_NAME_INSTALL_ALL + ext);
    File startall = new File(directory, Constants.SCRIPT_NAME_START_ALL + ext);
    try {
        PrintWriter kWriter = new PrintWriter(killall);
        PrintWriter iWriter = new PrintWriter(install);
        PrintWriter sWriter = new PrintWriter(startall);
        try {
            kWriter.println(ScriptConstants.BIN_BASH_COMMENT);
            iWriter.println(ScriptConstants.BIN_BASH_COMMENT);
            sWriter.println(ScriptConstants.BIN_BASH_COMMENT);
            for (Machine mac : machines) {
                iWriter.println(ScriptConstants.writeDashLine());
                iWriter.print(mac.writeToGlobalInstallScript());
                sWriter.println(ScriptConstants.writeDashLine());
                sWriter.print(mac.writeToGlobalStartScript());
                kWriter.println(ScriptConstants.writeDashLine());
                kWriter.print(mac.writeToGlobalKillScript());
            }
            kWriter.println(ScriptConstants.writeDashLine());
            iWriter.println(ScriptConstants.writeDashLine());
            sWriter.println(ScriptConstants.writeDashLine());
        } finally {
            if (kWriter != null) {
                kWriter.flush();
                kWriter.close();
            }
            if (iWriter != null) {
                iWriter.flush();
                iWriter.close();
            }
            if (sWriter != null) {
                sWriter.flush();
                sWriter.close();
            }
        }
    } catch (IOException e) {
        String msg = "String_Node_Str" + "String_Node_Str" + name + "String_Node_Str";
        log.trace(msg, e);
        throw new IOFailure(msg, e);
    }
}

Output:
         } finally {
-            if (kWriter != null) {
-                kWriter.flush();
-                kWriter.close();
-            }
-            if (iWriter != null) {
-                iWriter.flush();
-                iWriter.close();
-            }
-            if (sWriter != null) {
-                sWriter.flush();
-                sWriter.close();
-            }
+            sWriter.flush();
+            sWriter.close();
         }


Input:
public static byte[] cryptoSecretBoxOpenEasy(byte[] cipherText, byte[] nonce, byte[] key) throws SodiumLibraryException {
    if (key.length != sodium().crypto_secretbox_keybytes()) {
        throw new SodiumLibraryException("String_Node_Str" + key.length + "String_Node_Str");
    }
    if (nonce.length != sodium().crypto_secretbox_noncebytes()) {
        throw new SodiumLibraryException("String_Node_Str" + nonce.length + "String_Node_Str");
    }
    byte[] decrypted = new byte[(int) (cipherText.length - sodium().crypto_box_macbytes())];
    int rc = sodium().crypto_secretbox_open_easy(decrypted, cipherText, cipherText.length, nonce, key);
    if (rc != 0) {
        throw new SodiumLibraryException("String_Node_Str" + rc + "String_Node_Str");
    }
    return decrypted;
}

Output:
 public static byte[] cryptoSecretBoxOpenEasy(byte[] cipherText, byte[] nonce, byte[] key) throws SodiumLibraryException {
-    if (key.length != sodium().crypto_secretbox_keybytes()) {
+    if (key.length != sodium().crypto_secretbox_keybytes().intValue()) {
         throw new SodiumLibraryException("String_Node_Str" + key.length + "String_Node_Str");


Input:
public CsvArray run() throws ProcessorException, PersistenceException {
    CsvArray array = new CsvArray();
    buildProcess();
    IProcessor processor = ProcessorUtilities.getProcessor(process, null);
    processor.setContext(selectContext);
    File previousFile = temppath.toFile();
    if (previousFile.exists()) {
        previousFile.delete();
    }
    java.lang.Process executeprocess = processor.run(IProcessor.NO_STATISTICS, IProcessor.NO_TRACES, null);
    StringBuffer buffer = new StringBuffer();
    ProcessStreamTrashReaderUtil.readAndForget(executeprocess, buffer);
    final String errorMessage = buffer.toString();
    if (!"String_Node_Str".equals(buffer.toString())) {
        throw new PersistenceException(errorMessage) {
            private static final long serialVersionUID = 1L;
            public synchronized Throwable initCause(Throwable cause) {
                return super.initCause(cause);
            }
            public String getMessage() {
                StringTokenizer tokenizer = new StringTokenizer(errorMessage, "String_Node_Str");
                StringBuilder sqlError = new StringBuilder();
                if (tokenizer.countTokens() > 2) {
                    tokenizer.nextToken();
                    sqlError.append(tokenizer.nextToken()).append("String_Node_Str");
                }
                return sqlError.toString();
            }
        };
    } else {
        try {
            array = array.createFrom(previousFile, currentProcessEncoding);
        } catch (IOException ioe) {
            throw new ProcessorException(ioe);
        }
    }
    return array;
}

Output:
         } catch (IOException ioe) {
-            throw new ProcessorException(ioe);
+            throw new ProcessorException(ioe) {
+                public String getMessage() {
+                    return Messages.getString("String_Node_Str", System.getProperty("String_Node_Str"));
+                }
+            };
         }


Input:
private ContentResource isContentExists(File file) {
    String fileName = "String_Node_Str" + file.getName() + "String_Node_Str" + file.getName() + "String_Node_Str";
    ContentCollection userRoot = getUserRoot();
    try {
        ContentNode node = userRoot.getChild(fileName);
        if (node != null && node instanceof ContentResource) {
            return (ContentResource) node;
        }
        return null;
    } catch (ContentRepositoryException excp) {
        logger.log(Level.WARNING, "String_Node_Str" + fileName + "String_Node_Str", excp);
        return null;
    }
}

Output:
         if (node != null && node instanceof ContentResource) {
-            return (ContentResource) node;
+            return getModelURI(file);
         }


Input:
private static final String computeMD5SumFile(File file) throws IOException {
    MessageDigest md5Digest;
    try {
        md5Digest = MessageDigest.getInstance("String_Node_Str");
    } catch (NoSuchAlgorithmException e) {
        md5Digest = null;
    }
    try (InputStream is = new FileInputStream(file)) {
        new DigestInputStream(is, md5Digest);
    }
    return new BigInteger(1, md5Digest.digest()).toString(16);
}

Output:
     } catch (NoSuchAlgorithmException e) {
-        md5Digest = null;
+        throw new IOException(e);
     }


Input:
public int compare(Viewer viewer, Object e1, Object e2) {
    if (e1 == null || e2 == null) {
        return 0;
    }
    TransactionId tx1 = (TransactionId) e1;
    TransactionId tx2 = (TransactionId) e2;
    return (int) (tx1.getId() - tx2.getId());
}

Output:
     }
-    TransactionId tx1 = (TransactionId) e1;
-    TransactionId tx2 = (TransactionId) e2;
-    return (int) (tx1.getId() - tx2.getId());
+    Long b1 = ((IOseeBranch) e1).getId();
+    Long b2 = ((IOseeBranch) e1).getId();
+    if (b1 > b2) {
+        return -1;
+    }
+    if (b2 > b1) {
+        return 1;
+    }
+    return 0;
 }


Input:
public void serialize(OutputStream out, SerializeOpts opt) throws UnsupportedEncodingException, IOException, SaxonApiException {
    if (isAtomic())
        out.write(toString().getBytes(opt.getEncoding()));
    else if (mValue instanceof XdmValue) {
        Serializer ser = Util.getSerializer(opt);
        ser.setOutputStream(out);
        Util.writeXdmValue(asXdmValue(), ser);
    }
}

Output:
 public void serialize(OutputStream out, SerializeOpts opt) throws UnsupportedEncodingException, IOException, SaxonApiException {
-    if (isAtomic())
+    if (isAtomic() || isObject())
         out.write(toString().getBytes(opt.getEncoding()));


Input:
public static void handleOnPageBreak(IDataContent content, ExecutionContext context) {
    ReportItemDesign dataItemDesign = (ReportItemDesign) content.getGenerateBy();
    if (!needOnPageBreak(dataItemDesign)) {
        return;
    }
    try {
        IDataItemInstance dataItem = new DataItemInstance(content, context);
        if (handleJS(dataItem, dataItemDesign.getOnPageBreak(), context).didRun())
            return;
        IDataItemEventHandler eh = getEventHandler(dataItemDesign, context);
        if (eh != null)
            eh.onPageBreak(dataItem, context.getReportContext());
    } catch (Exception e) {
        addException(context, e, dataItemDesign.getHandle());
    }
}

Output:
     try {
-        IDataItemInstance dataItem = new DataItemInstance(content, context);
+        IDataItemInstance dataItem = new DataItemInstance(content, context, RunningState.PAGEBREAK);
         if (handleJS(dataItem, dataItemDesign.getOnPageBreak(), context).didRun())


Input:
private void superBreaker(String playerName, Block block) {
    int typeId = block.getTypeId();
    switch(typeId) {
        case 64:
            if (block.getData() < 8)
                dropItem(block, 324);
            break;
        case 71:
            if (block.getData() < 8)
                dropItem(block, 330);
            break;
        case 55:
            dropItem(block, 331);
            break;
        case 63:
        case 68:
            dropItem(block, 323);
            break;
        case 83:
            dropItem(block, 338);
            break;
        case 59:
        case 31:
            dropItem(block, 295);
            break;
        case 26:
            if (block.getData() < 4)
                dropItem(block, 355);
            break;
        case 75:
            dropItem(block, 76);
            break;
        case 93:
        case 94:
            dropItem(block, 356);
            break;
        default:
            dropItem(block, typeId);
            break;
    }
    if (Utils.logBlock != null)
        Utils.logBlock.queueBlockBreak(playerName, block.getState());
    block.setTypeId(0);
}

Output:
     if (Utils.logBlock != null)
-        Utils.logBlock.queueBlockBreak(playerName, block.getState());
+        Utils.logBlock.queueBlockBreak(player.getName(), block.getState());
     block.setTypeId(0);


Input:
private Map<String, String> parseHeaders(final Scanner scanner) throws BatchException {
    Map<String, String> headers = new HashMap<String, String>();
    while (scanner.hasNext() && !(scanner.hasNext(REG_EX_BLANK_LINE))) {
        if (scanner.hasNext(REG_EX_HEADER)) {
            scanner.next(REG_EX_HEADER);
            currentLineNumber++;
            MatchResult result = scanner.match();
            if (result.groupCount() == 2) {
                String headerName = result.group(1).trim().toLowerCase();
                String headerValue = result.group(2).trim();
                headers.put(headerName, headerValue);
            }
        } else {
            throw new BatchException(BatchException.INVALID_HEADER.addContent(scanner.next()));
        }
    }
    return headers;
}

Output:
             if (result.groupCount() == 2) {
-                String headerName = result.group(1).trim().toLowerCase();
+                String headerName = result.group(1).trim().toLowerCase(Locale.ENGLISH);
                 String headerValue = result.group(2).trim();


Input:
public String toString() {
    return "String_Node_Str" + getLabel() + "String_Node_Str" + alStorages.size() + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + getLabel() + "String_Node_Str" + alStorages.size() + "String_Node_Str";
+    return "String_Node_Str" + getLabel() + "String_Node_Str" + setType + "String_Node_Str" + alStorages.size() + "String_Node_Str";
 }


Input:
public boolean onBroughtToTop(IReportEditorPage prePage) {
    if (getEditorInput() != prePage.getEditorInput()) {
        setInput(prePage.getEditorInput());
    }
    previouPage = prePage;
    ISelection selection = new StructuredSelection(SessionHandleAdapter.getInstance().getMediator().getCurrentState().getSelectionObject());
    jsEditor.handleSelectionChanged(selection);
    return true;
}

Output:
     previouPage = prePage;
-    ISelection selection = new StructuredSelection(SessionHandleAdapter.getInstance().getMediator().getCurrentState().getSelectionObject());
-    jsEditor.handleSelectionChanged(selection);
+    IMediatorState state = SessionHandleAdapter.getInstance().getMediator().getCurrentState();
+    ReportRequest request = new ReportRequest(state.getSource());
+    List list = state.getSelectionObject();
+    request.setSelectionObject(list);
+    request.setType(ReportRequest.SELECTION);
+    SessionHandleAdapter.getInstance().getMediator().notifyRequest(request);
     return true;


Input:
private static Map<ModuleIdentifier, ModuleSpec> newModule(final String name, final String mainClass, final int level, final String prefix, final File... cp) throws Exception {
    Map<ModuleIdentifier, ModuleSpec> modules = new HashMap<>();
    String mId = name.replace("String_Node_Str", "String_Node_Str");
    ModuleSpec.Builder builder = ModuleSpec.build(ModuleIdentifier.fromString(mId));
    int l = (prefix.length() + mId.length() + level);
    Main.debug("String_Node_Str" + l + "String_Node_Str", prefix + mId);
    for (File file : cp) {
        String fname = "String_Node_Str" + file.getAbsolutePath();
        if (file.getName().startsWith("String_Node_Str") && !name.equals(file.getName())) {
            ModuleSpec dependency = newModule(file.getName(), null, level + 2, "String_Node_Str", file).values().iterator().next();
            builder.addDependency(DependencySpec.createModuleDependencySpec(dependency.getModuleIdentifier()));
            modules.put(dependency.getModuleIdentifier(), dependency);
        } else {
            Main.debug("String_Node_Str" + (fname.length() + level + 2) + "String_Node_Str", fname);
            if (file.getName().endsWith("String_Node_Str")) {
                builder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(ResourceLoaders.createJarResourceLoader(file.getName(), new JarFile(file))));
            } else {
                builder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(ResourceLoaders.createFileResourceLoader(file.getName(), file)));
            }
        }
    }
    Set<String> sysPaths = sysPaths();
    Main.trace("String_Node_Str");
    sysPaths.forEach(p -> Main.trace("String_Node_Str", p));
    builder.addDependency(DependencySpec.createSystemDependencySpec(sysPaths));
    builder.addDependency(DependencySpec.createLocalDependencySpec());
    if (mainClass != null) {
        builder.setMainClass(mainClass);
    }
    ModuleSpec module = builder.create();
    modules.put(module.getModuleIdentifier(), builder.create());
    return modules;
}

Output:
         if (file.getName().startsWith("String_Node_Str") && !name.equals(file.getName())) {
-            ModuleSpec dependency = newModule(file.getName(), null, level + 2, "String_Node_Str", file).values().iterator().next();
+            ModuleSpec dependency = newModule(file.getName(), level + 2, "String_Node_Str", file).values().iterator().next();
             builder.addDependency(DependencySpec.createModuleDependencySpec(dependency.getModuleIdentifier()));


Input:
public ReturnValue do_run() {
    AbstractWorkflowEngine engine = new PegasusWorkflowEngine();
    WorkflowDataModelFactory factory = new WorkflowDataModelFactory(options, config, params, metadata);
    AbstractWorkflowDataModel dataModel = factory.getWorkflowDataModel();
    ReturnValue retPegasus = engine.launchWorkflow(dataModel);
    if (!Boolean.parseBoolean(dataModel.getConfigs().get("String_Node_Str"))) {
        return retPegasus;
    }
    String wra = dataModel.getConfigs().get("String_Node_Str");
    if (wra == null || wra.isEmpty()) {
        return retPegasus;
    }
    int workflowrunId = Integer.parseInt(wra);
    int workflowrunaccession = this.metadata.get_workflow_run_accession(workflowrunId);
    String stdOut = retPegasus.getStdout();
    Pattern p = Pattern.compile("String_Node_Str");
    Matcher m = p.matcher(stdOut);
    String statusCmd = null;
    if (m.find()) {
        statusCmd = m.group(1);
    }
    p = Pattern.compile("String_Node_Str");
    m = p.matcher(stdOut);
    String statusDir = null;
    if (m.find()) {
        statusDir = m.group(1);
    }
    List<String> parentsLinkedToWR = new ArrayList<String>();
    WorkflowRun wr = null;
    for (String parentLinkedToWR : parentsLinkedToWR) {
        try {
            this.metadata.linkWorkflowRunAndParent(workflowrunId, Integer.parseInt(parentLinkedToWR));
        } catch (Exception e) {
            Log.error(e.getMessage());
        }
    }
    wr = metadata.getWorkflowRun(workflowrunaccession);
    if (retPegasus.getProcessExitStatus() != ReturnValue.SUCCESS || statusCmd == null) {
        metadata.update_workflow_run(workflowrunId, dataModel.getTags().get("String_Node_Str"), dataModel.getTags().get("String_Node_Str"), "String_Node_Str", statusCmd, dataModel.getWorkflowBundleDir(), "String_Node_Str", "String_Node_Str", wr.getHost(), 0, 0, retPegasus.getStderr(), retPegasus.getStdout());
        return (retPegasus);
    } else {
        metadata.update_workflow_run(workflowrunId, dataModel.getTags().get("String_Node_Str"), dataModel.getTags().get("String_Node_Str"), "String_Node_Str", statusCmd, dataModel.getWorkflowBundleDir(), "String_Node_Str", "String_Node_Str", wr.getHost(), Integer.parseInt(retPegasus.getAttribute("String_Node_Str")), Integer.parseInt(retPegasus.getAttribute("String_Node_Str")), retPegasus.getStderr(), retPegasus.getStdout());
        return ret;
    }
}

Output:
     } else {
-        metadata.update_workflow_run(workflowrunId, dataModel.getTags().get("String_Node_Str"), dataModel.getTags().get("String_Node_Str"), "String_Node_Str", statusCmd, dataModel.getWorkflowBundleDir(), "String_Node_Str", "String_Node_Str", wr.getHost(), Integer.parseInt(retPegasus.getAttribute("String_Node_Str")), Integer.parseInt(retPegasus.getAttribute("String_Node_Str")), retPegasus.getStderr(), retPegasus.getStdout());
+        metadata.update_workflow_run(workflowrunId, dataModel.getTags().get("String_Node_Str"), dataModel.getTags().get("String_Node_Str"), "String_Node_Str", statusCmd, dataModel.getWorkflowBundleDir(), "String_Node_Str", "String_Node_Str", wr.getHost(), 0, 0, retPegasus.getStderr(), retPegasus.getStdout());
         return ret;


Input:
private void toggleX() {
    ObservableList<Node> list = this.getChildren();
    if (list.size() > 1) {
        list.clear();
    } else {
        list.addAll(new Line(0, 0, getWidth(), getHeight()), new Line(getWidth(), 0, 0, getHeight()));
    }
}

Output:
     ObservableList<Node> list = this.getChildren();
-    if (list.size() > 1) {
+    if (list.size() > 0) {
         list.clear();


Input:
public void addDebugInfo(List<String> list) {
    list.add("String_Node_Str");
    if (this.crossCrop) {
        list.add("String_Node_Str");
    } else if (this.hasPlant()) {
        list.add("String_Node_Str");
        list.add("String_Node_Str" + ((ItemSeeds) this.seed).getUnlocalizedName());
        list.add("String_Node_Str" + Item.itemRegistry.getNameForObject(this.seed) + ':' + this.seedMeta);
        list.add("String_Node_Str" + SeedHelper.getPlant((ItemSeeds) this.seed).getUnlocalizedName());
        list.add("String_Node_Str" + this.getBlockMetadata());
        list.add("String_Node_Str" + this.growth);
        list.add("String_Node_Str" + this.gain);
        list.add("String_Node_Str" + this.strength);
        list.add("String_Node_Str" + this.isFertile());
        list.add("String_Node_Str" + this.isMature());
    } else if (this.weed) {
        list.add("String_Node_Str");
        list.add("String_Node_Str" + this.getBlockMetadata());
    } else {
        list.add("String_Node_Str");
    }
}

Output:
         list.add("String_Node_Str");
-        list.add("String_Node_Str" + ((ItemSeeds) this.seed).getUnlocalizedName());
+        list.add("String_Node_Str" + (this.seed).getUnlocalizedName());
         list.add("String_Node_Str" + Item.itemRegistry.getNameForObject(this.seed) + ':' + this.seedMeta);


Input:
protected void drawDataSet(Canvas c, RadarDataSet dataSet) {
    float sliceangle = mChart.getSliceAngle();
    float factor = mChart.getFactor();
    PointF center = mChart.getCenterOffsets();
    ArrayList<Entry> entries = dataSet.getYVals();
    Path surface = new Path();
    for (int j = 0; j < entries.size(); j++) {
        mRenderPaint.setColor(dataSet.getColor(j));
        Entry e = entries.get(j);
        PointF p = Utils.getPosition(center, e.getVal() * factor, sliceangle * j + mChart.getRotationAngle());
        if (j == 0)
            surface.moveTo(p.x, p.y);
        else
            surface.lineTo(p.x, p.y);
    }
    surface.close();
    if (dataSet.isDrawFilledEnabled()) {
        mRenderPaint.setStyle(Paint.Style.FILL);
        mRenderPaint.setAlpha(dataSet.getFillAlpha());
        c.drawPath(surface, mRenderPaint);
        mRenderPaint.setAlpha(255);
    }
    mRenderPaint.setStrokeWidth(dataSet.getLineWidth());
    mRenderPaint.setStyle(Paint.Style.STROKE);
    if (!dataSet.isDrawFilledEnabled() || dataSet.getFillAlpha() < 255)
        c.drawPath(surface, mRenderPaint);
}

Output:
         Entry e = entries.get(j);
-        PointF p = Utils.getPosition(center, e.getVal() * factor, sliceangle * j + mChart.getRotationAngle());
+        PointF p = Utils.getPosition(center, (e.getVal() - mChart.getYChartMin()) * factor, sliceangle * j + mChart.getRotationAngle());
         if (j == 0)


Input:
public void entityEntering(EntityPassiveItem item, Orientations orientation) {
    if (item.isCorrupted())
        return;
    readjustSpeed(item);
    if (!travelingEntities.containsKey(new Integer(item.entityId))) {
        travelingEntities.put(new Integer(item.entityId), new EntityData(item, orientation));
        if (item.container != null && item.container != this.container)
            ((PipeTransportItems) ((TileGenericPipe) item.container).pipe.transport).scheduleRemoval(item);
        item.container = container;
    }
    if (orientation != Orientations.YPos && orientation != Orientations.YNeg)
        item.setPosition(item.posX, yCoord + Utils.getPipeFloorOf(item.item), item.posZ);
    if (container.pipe instanceof IPipeTransportItemsHook)
        ((IPipeTransportItemsHook) container.pipe).entityEntered(item, orientation);
    if (APIProxy.isServerSide())
        if (item.synchroTracker.markTimeIfDelay(worldObj, 6 * BuildCraftCore.updateFactor))
            CoreProxy.sendToPlayers(createItemPacket(item, orientation), xCoord, yCoord, zCoord, 50, mod_BuildCraftTransport.instance);
    if (travelingEntities.size() > BuildCraftTransport.groupItemsTrigger) {
        groupEntities();
        if (travelingEntities.size() > BuildCraftTransport.maxItemsInPipes)
            worldObj.createExplosion(null, xCoord, yCoord, zCoord, 1);
    }
}

Output:
         if (item.synchroTracker.markTimeIfDelay(worldObj, 6 * BuildCraftCore.updateFactor))
-            CoreProxy.sendToPlayers(createItemPacket(item, orientation), xCoord, yCoord, zCoord, 50, mod_BuildCraftTransport.instance);
+            CoreProxy.sendToPlayers(createItemPacket(item, orientation), worldObj, xCoord, yCoord, zCoord, 50, mod_BuildCraftTransport.instance);
     if (travelingEntities.size() > BuildCraftTransport.groupItemsTrigger) {


Input:
private void updatePostsWithCurrentTag(ReaderActions.RequestDataAction updateAction, RefreshType refreshType) {
    if (hasCurrentTag())
        updatePostsWithTag(mCurrentTag, updateAction, refreshType);
}

Output:
 private void updatePostsWithCurrentTag(ReaderActions.RequestDataAction updateAction, RefreshType refreshType) {
-    if (hasCurrentTag())
+    if (hasCurrentTag()) {
         updatePostsWithTag(mCurrentTag, updateAction, refreshType);


Input:
public Spans getSpans(final IndexReader reader, final Searcher searcher) throws IOException {
    return new Spans() {
        private Weight typeWeight = sectionTypeQuery.weight(searcher);
        private Scorer typeScorer = typeWeight.scorer(reader);

        private boolean moreType = true;
        private boolean typeCanSkip = true;
        private Spans textSpans = textQuery.getSpans(reader, searcher);
        private boolean moreText = true;
        private boolean firstTime = true;
        public boolean next() throws IOException {
            if (moreText)
                moreText = textSpans.next();
            if (firstTime) {
                moreType = typeScorer.next();
                firstTime = false;
            }
            return advance();
        }
        public boolean skipTo(int target) throws IOException {
            moreText = textSpans.skipTo(target);
            skipType(target);
            return advance();
        }
        private void skipType(int target) throws IOException {
            if (typeCanSkip) {
                try {
                    moreType = typeScorer.skipTo(target);
                } catch (UnsupportedOperationException e) {
                    typeCanSkip = false;
                }
            }
            if (!typeCanSkip) {
                while (moreType && typeScorer.doc() < target) moreType = typeScorer.next();
            }
        }
        private boolean advance() throws IOException {
            while (moreText && moreType) {
                final int textChunk = textSpans.doc();
                final int typeChunk = typeScorer.doc();
                if (textChunk < typeChunk)
                    moreText = textSpans.skipTo(typeChunk);
                else if (textChunk > typeChunk)
                    skipType(textChunk);
                else
                    break;
            }
            return moreText && moreType;
        }
        public int doc() {
            return textSpans.doc();
        }
        public int start() {
            return textSpans.start();
        }
        public int end() {
            return textSpans.end();
        }
        public float score() {
            return textSpans.score();
        }
        public int coordBits() {
            return textSpans.coordBits();
        }
        public Collection allTerms() {
            return textSpans.allTerms();
        }
        public String toString() {
            return textSpans.toString();
        }
    };
}

Output:
     return new Spans() {
-        private Weight typeWeight = sectionTypeQuery.weight(searcher);
-        private Scorer typeScorer = typeWeight.scorer(reader);
+        private Spans typeSpans = typeQuery.getSpans(reader, searcher);


Input:
boolean checkAppSwitchAllowedLocked(int callingPid, int callingUid, String name) {
    if (mAppSwitchesAllowedTime < SystemClock.uptimeMillis()) {
        return true;
    }
    final int perm = checkComponentPermission(android.Manifest.permission.STOP_APP_SWITCHES, callingPid, callingUid, -1, true);
    if (perm == PackageManager.PERMISSION_GRANTED) {
        return true;
    }
    Slog.w(TAG, name + "String_Node_Str" + callingUid + "String_Node_Str");
    return false;
}

Output:
     }
-    final int perm = checkComponentPermission(android.Manifest.permission.STOP_APP_SWITCHES, callingPid, callingUid, -1, true);
+    int perm = checkComponentPermission(android.Manifest.permission.STOP_APP_SWITCHES, sourcePid, sourceUid, -1, true);
     if (perm == PackageManager.PERMISSION_GRANTED) {


Input:
public void start() {
    server = new Server();
    HttpConfiguration http_config = new HttpConfiguration();
    http_config.setSecureScheme("String_Node_Str");
    http_config.setSecurePort(8443);
    http_config.setOutputBufferSize(32768);
    ServerConnector http = new ServerConnector(server, new HttpConnectionFactory(http_config));
    http.setPort(8080);
    http.setIdleTimeout(30000);
    SslContextFactory sslContextFactory = new SslContextFactory();
    sslContextFactory.setKeyStorePath(this.getClass().getResource("String_Node_Str").toExternalForm());
    sslContextFactory.setKeyStorePassword("String_Node_Str");
    sslContextFactory.setKeyManagerPassword("String_Node_Str");
    HttpConfiguration httpsConfig = new HttpConfiguration(http_config);
    httpsConfig.addCustomizer(new SecureRequestCustomizer());
    ServerConnector https = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()), new HttpConnectionFactory(httpsConfig));
    https.setPort(8443);
    https.setIdleTimeout(500000);
    server.setConnectors(new Connector[] { http, https });
    ServletHandler handler = new ServletHandler();
    server.setHandler(handler);
    handler.addServletWithMapping(MockGetServlet.class, "String_Node_Str");
    handler.addServletWithMapping(MockPostServlet.class, "String_Node_Str");
    handler.addServletWithMapping(MockBasicAuthenticationServlet.class, "String_Node_Str");
    handler.addServletWithMapping(MockMultiPartServlet.class, "String_Node_Str");
    try {
        server.start();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

Output:
     handler.addServletWithMapping(MockBasicAuthenticationServlet.class, "String_Node_Str");
-    handler.addServletWithMapping(MockMultiPartServlet.class, "String_Node_Str");
+    handler.addServletWithMapping(MockPartServlet.class, "String_Node_Str");
     try {


Input:
public String getClusterUser() {
    return conf.get(GrillConfConstants.GRILL_SESSION_CLUSTER_USER);
}

Output:
 public String getClusterUser() {
-    return conf.get(GrillConfConstants.GRILL_SESSION_CLUSTER_USER);
+    return conf.get(GrillConfConstants.GRILL_SESSION_CLUSTER_USER, submittedUser);
 }


Input:
public boolean execute(LocalDataArea lda) {
    if (lda.stack.size() == 0) {
        return false;
    }
    lda.stack.push(MBStringLengthActionItem.getResult(lda.pop()));
    return true;
}

Output:
 public boolean execute(LocalDataArea lda) {
-    if (lda.stack.size() == 0) {
+    if (lda.stack.isEmpty()) {
         return false;


Input:
public void error(String msg, LogEvent event, Throwable t) {
    long current = System.currentTimeMillis();
    if (lastException + EXCEPTION_INTERVAL < current || exceptionCount++ < MAX_EXCEPTIONS) {
        logger.error(msg, t);
    }
    lastException = current;
    if (!appender.isExceptionSuppressed() && t != null) {
        throw new AppenderRuntimeException(msg, t);
    }
}

Output:
     if (lastException + EXCEPTION_INTERVAL < current || exceptionCount++ < MAX_EXCEPTIONS) {
-        logger.error(msg, t);
+        LOGGER.error(msg, t);
     }


Input:
private void buildNamespaceSupport(NamespaceSupport nss, Node node) {
    if (node.getNodeType() != Node.ELEMENT_NODE)
        return;
    buildNamespaceSupport(nss, node.getParentNode());
    nss.pushContext();
    NamedNodeMap atts = node.getAttributes();
    for (int i = 0; i < atts.getLength(); i++) {
        Attr a = (Attr) atts.item(i);
        if ("String_Node_Str".equals(a.getPrefix())) {
            nss.declarePrefix(a.getLocalName(), a.getValue());
            continue;
        }
        if ("String_Node_Str".equals(a.getName())) {
            nss.declarePrefix("String_Node_Str", a.getValue());
            continue;
        }
    }
}

Output:
 private void buildNamespaceSupport(NamespaceSupport nss, Node node) {
-    if (node.getNodeType() != Node.ELEMENT_NODE)
+    if (node == null || node.getNodeType() != Node.ELEMENT_NODE)
         return;


Input:
public void testFixJoin() throws Exception {
    final String expected = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    try (AsOfPartitionedJoinRecordSource source = new AsOfPartitionedJoinRecordSource(compiler.compileSource(factory, "String_Node_Str"), 0, new NoRowidSource().of(compiler.compileSource(factory, "String_Node_Str")), 0, keys, keys, 128, 128, 128)) {
        printer.printCursor(source, factory);
        TestUtils.assertEquals(expected, sink);
        source.reset();
        sink.clear();
        printer.printCursor(source, factory);
        TestUtils.assertEquals(expected, sink);
    }
}

Output:
     try (AsOfPartitionedJoinRecordSource source = new AsOfPartitionedJoinRecordSource(compiler.compileSource(factory, "String_Node_Str"), 0, new NoRowidSource().of(compiler.compileSource(factory, "String_Node_Str")), 0, keys, keys, 128, 128, 128)) {
-        printer.printCursor(source, factory);
+        printer.print(source, factory);
         TestUtils.assertEquals(expected, sink);


Input:
private static List<ModuleNeeded> getModulesNeededForComponents() {
    initCache();
    if (isCreated) {
        List<ModuleNeeded> importNeedsList = new ArrayList<ModuleNeeded>();
        ComponentsCache cache = ComponentManager.getComponentCache();
        EMap<String, EList<ComponentInfo>> map = cache.getComponentEntryMap();
        Set<String> set = map.keySet();
        Iterator it = set.iterator();
        Map<String, Boolean> bundlesAvailable = new HashMap<String, Boolean>();
        while (it.hasNext()) {
            String key = (String) it.next();
            EList<ComponentInfo> value = map.get(key);
            for (ComponentInfo info : value) {
                Boolean available = bundlesAvailable.get(info.getSourceBundleName());
                if (available == null) {
                    available = Platform.getBundle(info.getSourceBundleName()) != null;
                    bundlesAvailable.put(info.getSourceBundleName(), available);
                }
                if (!available) {
                    continue;
                }
                EList emfImportList = info.getImportType();
                for (int i = 0; i < emfImportList.size(); i++) {
                    IMPORTType importType = (IMPORTType) emfImportList.get(i);
                    collectModuleNeeded(key, importType, importNeedsList);
                }
            }
        }
        return importNeedsList;
    } else {
        List<ModuleNeeded> importNeedsList = new ArrayList<ModuleNeeded>();
        if (GlobalServiceRegister.getDefault().isServiceRegistered(IComponentsService.class)) {
            IComponentsService service = (IComponentsService) GlobalServiceRegister.getDefault().getService(IComponentsService.class);
            IComponentsFactory compFac = service.getComponentsFactory();
            Set<IComponent> componentList = compFac.getComponents();
            for (IComponent comp : componentList.toArray(new IComponent[0])) {
                importNeedsList.addAll(comp.getModulesNeeded());
            }
        }
        return importNeedsList;
    }
}

Output:
             IComponentsFactory compFac = service.getComponentsFactory();
-            Set<IComponent> componentList = compFac.getComponents();
-            for (IComponent comp : componentList.toArray(new IComponent[0])) {
+            for (IComponent comp : compFac.readComponents()) {
                 importNeedsList.addAll(comp.getModulesNeeded());


Input:
protected void addRequest(GitHubData request) {
    request.addOnInitListener(this);
    if (!requests.contains(request))
        requests.add(request);
    if (listener != null)
        listener.onRequest(this, request);
}

Output:
     request.addOnInitListener(this);
-    if (!requests.contains(request))
-        requests.add(request);
+    requests.add(request);
     if (listener != null)


Input:
public static void createMarketWindow() {
    CreateMarketTrainingDialog dialog = new CreateMarketTrainingDialog(EncogWorkBench.getInstance().getMainWindow());
    dialog.getFromDay().setValue(1);
    dialog.getFromMonth().setValue(1);
    dialog.getFromYear().setValue(1995);
    dialog.getToDay().setValue(31);
    dialog.getToMonth().setValue(12);
    dialog.getToYear().setValue(2005);
    dialog.getInputWindow().setValue(7);
    dialog.getOutputWindow().setValue(1);
    if (dialog.process()) {
        String ticker = dialog.getTicker().getValue();
        int fromDay = dialog.getFromDay().getValue();
        int fromMonth = dialog.getFromMonth().getValue();
        int fromYear = dialog.getFromYear().getValue();
        int toDay = dialog.getToDay().getValue();
        int toMonth = dialog.getToMonth().getValue();
        int toYear = dialog.getToYear().getValue();
        int inputWindow = dialog.getInputWindow().getValue();
        int outputWindow = dialog.getOutputWindow().getValue();
        Calendar begin = new GregorianCalendar(fromYear, fromMonth - 1, fromDay);
        Calendar end = new GregorianCalendar(toYear, toMonth - 1, toDay);
        try {
            final MarketLoader loader = new YahooFinanceLoader();
            final MarketNeuralDataSet market = new MarketNeuralDataSet(loader, inputWindow, outputWindow);
            final MarketDataDescription desc = new MarketDataDescription(new TickerSymbol(ticker), MarketDataType.ADJUSTED_CLOSE, true, true);
            market.addDescription(desc);
            if (end.getTimeInMillis() > begin.getTimeInMillis()) {
                EncogWorkBench.displayError("String_Node_Str", "String_Node_Str");
                return;
            }
            market.load(begin.getTime(), end.getTime());
            market.generate();
            BasicNeuralDataSet training = new BasicNeuralDataSet();
            for (NeuralDataPair data : market) {
                training.add(data);
            }
            training.setDescription("String_Node_Str" + ticker);
            EncogWorkBench.getInstance().getCurrentFile().add(EncogDocumentOperations.generateNextID("String_Node_Str"), training);
            EncogWorkBench.getInstance().getMainWindow().redraw();
        } catch (LoaderError e) {
            EncogWorkBench.displayError("String_Node_Str", "String_Node_Str");
        }
    }
}

Output:
             market.addDescription(desc);
-            if (end.getTimeInMillis() > begin.getTimeInMillis()) {
+            if (end.getTimeInMillis() < begin.getTimeInMillis()) {
                 EncogWorkBench.displayError("String_Node_Str", "String_Node_Str");


Input:
public void test1STP() throws IOException, StructureException {
    testID("String_Node_Str", 1, 4);
}

Output:
 public void test1STP() throws IOException, StructureException {
-    testID("String_Node_Str", 1, 4);
+    comparePdbVsMmcif("String_Node_Str", 1, 4);
 }