Input:
private int pollForNewUndeliveredResources(SubscriptionTable theSubscriptionTable) {
    Subscription subscription = toResource(Subscription.class, theSubscriptionTable.getSubscriptionResource(), false);
    RuntimeResourceDefinition resourceDef = validateCriteriaAndReturnResourceDefinition(subscription);
    SearchParameterMap criteriaUrl = translateMatchUrl(subscription.getCriteria(), resourceDef);
    criteriaUrl = new SearchParameterMap();
    long start = theSubscriptionTable.getMostRecentMatch().getTime();
    long end = System.currentTimeMillis() - getConfig().getSubscriptionPollDelay();
    if (end <= start) {
        ourLog.trace("String_Node_Str");
        return 0;
    }
    ourLog.debug("String_Node_Str", new Object[] { subscription.getId().getIdPart(), new InstantDt(new Date(start)), new InstantDt(new Date(end)) });
    DateRangeParam range = new DateRangeParam();
    range.setLowerBound(new DateParam(QuantityCompararatorEnum.GREATERTHAN, start));
    range.setUpperBound(new DateParam(QuantityCompararatorEnum.LESSTHAN, end));
    criteriaUrl.setLastUpdated(range);
    criteriaUrl.setSort(new SortSpec(Constants.PARAM_LASTUPDATED, SortOrderEnum.ASC));
    IFhirResourceDao<? extends IBaseResource> dao = getDao(resourceDef.getImplementingClass());
    IBundleProvider results = dao.search(criteriaUrl);
    if (results.size() == 0) {
        return 0;
    }
    ourLog.info("String_Node_Str", results.size(), subscription.getId().getIdPart());
    List<SubscriptionFlaggedResource> flags = new ArrayList<SubscriptionFlaggedResource>();
    Date mostRecentMatch = null;
    for (IBaseResource next : results.getResources(0, results.size())) {
        Date updated = ResourceMetadataKeyEnum.PUBLISHED.get((IResource) next).getValue();
        if (mostRecentMatch == null) {
            mostRecentMatch = updated;
        } else {
            long mostRecentMatchTime = mostRecentMatch.getTime();
            long updatedTime = updated.getTime();
            if (mostRecentMatchTime < updatedTime) {
                mostRecentMatch = updated;
            }
        }
        SubscriptionFlaggedResource nextFlag = new SubscriptionFlaggedResource();
        Long pid = IDao.RESOURCE_PID.get((IResource) next);
        nextFlag.setResource(myEntityManager.find(ResourceTable.class, pid));
        nextFlag.setSubscription(theSubscriptionTable);
        nextFlag.setVersion(next.getIdElement().getVersionIdPartAsLong());
        flags.add(nextFlag);
    }
    mySubscriptionFlaggedResourceDataDao.save(flags);
    ourLog.debug("String_Node_Str", subscription.getId().getIdPart(), new InstantDt(mostRecentMatch));
    theSubscriptionTable.setMostRecentMatch(mostRecentMatch);
    myEntityManager.merge(theSubscriptionTable);
    return results.size();
}

Output:
     for (IBaseResource next : results.getResources(0, results.size())) {
-        Date updated = ResourceMetadataKeyEnum.PUBLISHED.get((IResource) next).getValue();
+        Date updated = ResourceMetadataKeyEnum.UPDATED.get((IResource) next).getValue();
         if (mostRecentMatch == null) {


Input:
protected void pageChange(int newPageIndex) {
    super.pageChange(newPageIndex);
    if (newPageIndex == RESULT_PAGE_INDEX) {
        if (masterPage.isDirty()) {
            masterPage.doSave(null);
        }
        setSaveActionButtonState(false);
    }
    if (isRefreshResultPage) {
        resultPage.refresh(getMasterPage());
        isRefreshResultPage = false;
    } else {
        EventManager.getInstance().publish(masterPage.analysisItem.getAnalysis(), EventEnum.DQ_DYNAMIC_SWITCH_MASTER_RESULT_PAGE, null);
    }
}

Output:
     } else {
-        EventManager.getInstance().publish(masterPage.analysisItem.getAnalysis(), EventEnum.DQ_DYNAMIC_SWITCH_MASTER_RESULT_PAGE, null);
+        EventManager.getInstance().publish(resultPage.getAnalysisHandler().getAnalysis(), EventEnum.DQ_DYNAMIC_SWITCH_MASTER_RESULT_PAGE, null);
     }


Input:
public boolean index(long fullIndex) throws IOException {
    if (LOG.isDebugEnabled()) {
        LOG.debug(SingleChronicleQueueStore.IndexOffset.toBinaryString(fullIndex));
        LOG.debug(SingleChronicleQueueStore.IndexOffset.toScale());
    }
    final long nextCycle = ChronicleQueue.cycle(fullIndex);
    if (nextCycle != queue.lastCycle())
        cycle(nextCycle);
    final long position = this.store.moveToIndex(wire, subIndex(fullIndex));
    final Bytes<?> readContext = wire.bytes();
    readContext.readPosition(position);
    readContext.readLimit(readContext.capacity());
    if (position != -1) {
        this.index = fullIndex - 1;
        return true;
    }
    return false;
}

Output:
     }
-    final long nextCycle = ChronicleQueue.cycle(fullIndex);
-    if (nextCycle != queue.lastCycle())
-        cycle(nextCycle);
-    final long position = this.store.moveToIndex(wire, subIndex(fullIndex));
-    final Bytes<?> readContext = wire.bytes();
-    readContext.readPosition(position);
-    readContext.readLimit(readContext.capacity());
-    if (position != -1) {
-        this.index = fullIndex - 1;
-        return true;
-    }
-    return false;
+    return ChronicleQueue.index(cycle(), index);
 }


Input:
private String getCollectionName(final String suffix) {
    return getScopePrefix() + suffix;
}

Output:
 private String getCollectionName(final String suffix) {
-    return getScopePrefix() + suffix;
+    return COLLECTION_NAME_UTIL.getName(owner, project, stack, suffix);
 }


Input:
private void randomlyChooseTargetPos() {
    if (possible.isEmpty()) {
        targetPos = null;
        return;
    }
    targetPos = possible.get(world.rand.nextInt(possible.size()));
}

Output:
 private void randomlyChooseTargetPos() {
-    if (possible.isEmpty()) {
+    List<BlockPos> targetsNeedingPower = new ArrayList<>();
+    for (BlockPos position : targetPositions) {
+        if (powerNeededAt(position)) {
+            targetsNeedingPower.add(position);
+        }
+    }
+    if (targetsNeedingPower.isEmpty()) {
         targetPos = null;


Input:
public void bindView(View view, Context context, Cursor cursor) {
    Resources r = context.getResources();
    ImageView iv = (ImageView) view.findViewById(R.id.transfer_icon);
    int status = cursor.getInt(cursor.getColumnIndexOrThrow(BluetoothShare.STATUS));
    int dir = cursor.getInt(cursor.getColumnIndexOrThrow(BluetoothShare.DIRECTION));
    if (BluetoothShare.isStatusError(status)) {
        iv.setImageResource(android.R.drawable.stat_notify_error);
    } else {
        if (dir == BluetoothShare.DIRECTION_OUTBOUND) {
            iv.setImageResource(android.R.drawable.stat_sys_upload_done);
        } else {
            iv.setImageResource(android.R.drawable.stat_sys_download_done);
        }
    }
    TextView tv = (TextView) view.findViewById(R.id.transfer_title);
    String title = cursor.getString(cursor.getColumnIndexOrThrow(BluetoothShare.FILENAME_HINT));
    if (title == null) {
        title = mContext.getString(R.string.unknown_file);
    }
    tv.setText(title);
    tv = (TextView) view.findViewById(R.id.targetdevice);
    BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
    int destinationColumnId = cursor.getColumnIndexOrThrow(BluetoothShare.DESTINATION);
    BluetoothDevice remoteDevice = adapter.getRemoteDevice(cursor.getString(destinationColumnId));
    String deviceName = BluetoothOppManager.getInstance(context).getDeviceName(remoteDevice);
    tv.setText(deviceName);
    long totalBytes = cursor.getLong(cursor.getColumnIndexOrThrow(BluetoothShare.TOTAL_BYTES));
    if (BluetoothShare.isStatusCompleted(status)) {
        tv = (TextView) view.findViewById(R.id.complete_text);
        tv.setVisibility(View.VISIBLE);
        if (BluetoothShare.isStatusError(status)) {
            tv.setText(BluetoothOppUtility.getStatusDescription(mContext, status));
        } else {
            String completeText;
            if (dir == BluetoothShare.DIRECTION_INBOUND) {
                completeText = r.getString(R.string.download_success, Formatter.formatFileSize(mContext, totalBytes));
            } else {
                completeText = r.getString(R.string.upload_success, Formatter.formatFileSize(mContext, totalBytes));
            }
            tv.setText(completeText);
        }
        int dateColumnId = cursor.getColumnIndexOrThrow(BluetoothShare.TIMESTAMP);
        long time = cursor.getLong(dateColumnId);
        Date d = new Date(time);
        CharSequence str = DateUtils.isToday(time) ? DateFormat.getTimeFormat(mContext).format(d) : DateFormat.getDateFormat(mContext).format(d);
        tv = (TextView) view.findViewById(R.id.complete_date);
        tv.setVisibility(View.VISIBLE);
        tv.setText(str);
    }
}

Output:
         if (BluetoothShare.isStatusError(status)) {
-            tv.setText(BluetoothOppUtility.getStatusDescription(mContext, status));
+            tv.setText(BluetoothOppUtility.getStatusDescription(mContext, status, deviceName));
         } else {


Input:
public void onActivityResult(int request, int result, Intent data) {
    super.onActivityResult(request, result, data);
    switch(request) {
        case REQUEST_CONNECT:
            if (result != RESULT_OK) {
                shouldResolveError = false;
            }
            if (!mGoogleApiClient.isConnecting() && !mGoogleApiClient.isConnected()) {
                mGoogleApiClient.connect();
            } else {
                showAccountDialog();
            }
            isResolvingError = false;
            break;
        case REQUEST_LOGIN:
            if (result == RESULT_OK) {
                GoogleSignInResult signInResult = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
                if (signInResult.isSuccess()) {
                    try {
                        GoogleSignInAccount account = signInResult.getSignInAccount();
                        mGoogleEmail = account.getEmail();
                        PushSocialLoginPayload payload = new PushSocialLoginPayload(account.getIdToken(), SERVICE_TYPE_GOOGLE);
                        mDispatcher.dispatch(AccountActionBuilder.newPushSocialLoginAction(payload));
                    } catch (NullPointerException exception) {
                        disconnectGoogleClient();
                        AppLog.e(T.NUX, "String_Node_Str", exception);
                        showErrorDialog(getString(R.string.login_error_generic));
                    }
                } else {
                    switch(signInResult.getStatus().getStatusCode()) {
                        case GoogleSignInStatusCodes.INTERNAL_ERROR:
                            AppLog.e(T.NUX, "String_Node_Str");
                            showErrorDialog(getString(R.string.login_error_generic) + getString(R.string.login_error_suffix_internal));
                            break;
                        case GoogleSignInStatusCodes.INVALID_ACCOUNT:
                            AppLog.e(T.NUX, "String_Node_Str");
                            showErrorDialog(getString(R.string.login_error_generic) + getString(R.string.login_error_suffix_invalid));
                            break;
                        case GoogleSignInStatusCodes.NETWORK_ERROR:
                            AppLog.e(T.NUX, "String_Node_Str");
                            showErrorDialog(getString(R.string.error_generic_network));
                            break;
                        case GoogleSignInStatusCodes.SIGN_IN_CANCELLED:
                            AppLog.e(T.NUX, "String_Node_Str");
                            break;
                        case GoogleSignInStatusCodes.SIGN_IN_FAILED:
                            AppLog.e(T.NUX, "String_Node_Str");
                            showErrorDialog(getString(R.string.login_error_generic));
                            break;
                        case GoogleSignInStatusCodes.SIGN_IN_REQUIRED:
                            AppLog.e(T.NUX, "String_Node_Str");
                            showErrorDialog(getString(R.string.login_error_generic));
                            break;
                        default:
                            AppLog.e(T.NUX, "String_Node_Str");
                            showErrorDialog(getString(R.string.login_error_generic));
                            break;
                    }
                }
            } else {
                AppLog.e(T.NUX, "String_Node_Str");
                showErrorDialog(getString(R.string.login_error_generic));
            }
            break;
    }
}

Output:
                             AppLog.e(T.NUX, "String_Node_Str");
-                            showErrorDialog(getString(R.string.login_error_generic) + getString(R.string.login_error_suffix_internal));
+                            showErrorDialog(getString(R.string.login_error_generic));
                             break;


Input:
protected void setUp() throws Exception {
    Iterator it = ResourceRegistrar.getResourcesUniqueNames().iterator();
    while (it.hasNext()) {
        String name = (String) it.next();
        ResourceRegistrar.unregister(ResourceRegistrar.get(name));
    }
    pds = new PoolingDataSource();
    pds.setClassName(MockXADataSource.class.getName());
    pds.setUniqueName("String_Node_Str");
    pds.setMaxPoolSize(3);
    pds.init();
    new File(TransactionManagerServices.getConfiguration().getLogPart1Filename()).delete();
    new File(TransactionManagerServices.getConfiguration().getLogPart2Filename()).delete();
    JdbcConnectionHandle handle = (JdbcConnectionHandle) pds.getConnection();
    xaResource = (MockXAResource) handle.getPooledConnection().getXAResource();
}

Output:
     pds.setUniqueName("String_Node_Str");
-    pds.setMaxPoolSize(3);
+    pds.setMinPoolSize(1);
+    pds.setMaxPoolSize(1);
     pds.init();


Input:
public static void sendIsItAlive(OurSim ourSim, Long time, String interested, String monitored) {
    ActiveEntity interestedObj = ourSim.getGrid().getObject(interested);
    Monitor monitor = interestedObj.getMonitor(monitored);
    if (monitor == null) {
        return;
    }
    Event isItAliveReceivedEvent = ourSim.createEvent(FailureDetectionEvents.IS_IT_ALIVE_RECEIVED, time, interested, monitored, monitor.isCreatingConnection());
    interestedObj.isItAliveSent(monitored, time);
    ourSim.addNetworkEvent(isItAliveReceivedEvent);
    Event isItAliveSentEvent = ourSim.createEvent(FailureDetectionEvents.IS_IT_ALIVE_SENT, time + interestedObj.getTimeToNextPing(monitored, time), interested, monitored);
    ourSim.addEvent(isItAliveSentEvent);
}

Output:
     ourSim.addNetworkEvent(isItAliveReceivedEvent);
-    Event isItAliveSentEvent = ourSim.createEvent(FailureDetectionEvents.IS_IT_ALIVE_SENT, time + interestedObj.getTimeToNextPing(monitored, time), interested, monitored);
-    ourSim.addEvent(isItAliveSentEvent);
+    if (ourSim.getBooleanProperty(Configuration.PROP_USE_FAILURE_DETECTOR)) {
+        Event isItAliveSentEvent = ourSim.createEvent(FailureDetectionEvents.IS_IT_ALIVE_SENT, time + interestedObj.getTimeToNextPing(monitored, time), interested, monitored);
+        ourSim.addEvent(isItAliveSentEvent);
+    }
 }


Input:
public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
    URI uri = this.getLocationURI(request, response, context);
    String method = request.getRequestLine().getMethod();
    if (method.equalsIgnoreCase(HttpHead.METHOD_NAME)) {
        return new HttpHead(uri);
    }
    if (method.equalsIgnoreCase(HttpPropFind.METHOD_NAME)) {
        return new HttpPropFind(uri);
    }
    if (method.equalsIgnoreCase(HttpLock.METHOD_NAME)) {
        return new HttpLock(uri);
    }
    return new HttpGet(uri);
}

Output:
     if (method.equalsIgnoreCase(HttpPropFind.METHOD_NAME)) {
-        return new HttpPropFind(uri);
+        return new HttpPropFind(this.getLocationURI(request, response, context));
     }


Input:
public void addActivity(Workflow wf, String relatedStepId, boolean before, AbstractActivity activity, TopologyContext topologyContext) {
    if (WorkflowUtils.isNativeNode(activity.getNodeId(), topologyContext)) {
        throw new BadWorkflowOperationException("String_Node_Str");
    }
    if (relatedStepId != null) {
        if (before) {
            insertActivityStep(wf, relatedStepId, activity);
        } else {
            appendActivityStep(wf, relatedStepId, activity);
        }
    } else {
        addActivityStep(wf, activity.getNodeId(), activity);
    }
}

Output:
 public void addActivity(Workflow wf, String relatedStepId, boolean before, AbstractActivity activity, TopologyContext topologyContext) {
-    if (WorkflowUtils.isNativeNode(activity.getNodeId(), topologyContext)) {
+    if (WorkflowUtils.isNativeOrSubstitutionNode(activity.getNodeId(), topologyContext)) {
         throw new BadWorkflowOperationException("String_Node_Str");


Input:
public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int par4, int par5, int par6, int par7, float par8, float par9, float par10) {
    if (!world.isRemote && stack.getItemDamage() == 0 && getStoredXP(stack) != 0) {
        int toAdd = removeStoredXP(stack, TRANSFER_RATE);
        if (toAdd > 0) {
            player.addExperience(toAdd);
            return true;
        }
    }
    return false;
}

Output:
         if (toAdd > 0) {
-            player.addExperience(toAdd);
+            addXP(player, toAdd);
             return true;


Input:
public String downloadWeeklyPillReminderReport(String clinicId, String patientId, LocalDate startDate, LocalDate endDate, Model uiModel) {
    DateFilter filter = new DateFilter().setDates(startDate, endDate);
    endDate.plusDays(1);
    if (filter.isMoreThanOneYear()) {
        return error(uiModel, "String_Node_Str");
    } else {
        return format("String_Node_Str", clinicId, patientId, filter.startDate.toString("String_Node_Str"), filter.getEndDate().toString("String_Node_Str"));
    }
}

Output:
     } else {
-        return format("String_Node_Str", clinicId, patientId, filter.startDate.toString("String_Node_Str"), filter.getEndDate().toString("String_Node_Str"));
+        return format("String_Node_Str", clinicId, patientId, filter.startDate.toString("String_Node_Str"), filter.getEndDate().plusDays(1).toString("String_Node_Str"));
     }


Input:
public static void assertSameHtml(String html1, String html2) throws SAXException, IOException, TransformerException {
    html1 = preProcessHTML(html1);
    html1 = cleanupHtml(html1);
    html2 = preProcessHTML(html2);
    html2 = cleanupHtml(html2);
    assertEquals(html1, html2);
}

Output:
 public static void assertSameHtml(String html1, String html2) throws SAXException, IOException, TransformerException {
-    html1 = preProcessHTML(html1);
+    html1 = preProcessHtml(html1);
     html1 = cleanupHtml(html1);


Input:
private boolean isSourceObject(String id) {
    return (id.startsWith(sourceObjectSet + '/') && id.length() > sourceObjectSet.length() + 1);
}

Output:
 private boolean isSourceObject(String id) {
-    return (id.startsWith(sourceObjectSet + '/') && id.length() > sourceObjectSet.length() + 1);
+    return (id.startsWith("String_Node_Str" + sourceObjectSet + '/') && id.length() > sourceObjectSet.length() + 2);
 }


Input:
public EntityResponse getEntity(String entitySetName, final OEntityKey entityKey, QueryInfo queryInfo) {
    final EdmEntitySet ees = getMetadata().getEdmEntitySet(entitySetName);
    final InMemoryEntityInfo<?, ?> ei = eis.get(entitySetName);
    final String[] keyList = ei.keys;
    Iterable<Object> iter = (Iterable<Object>) ei.get.apply();
    final Object rt = Enumerable.create(iter).firstOrNull(new Predicate1<Object>() {
        public boolean apply(Object input) {
            HashMap<String, Object> idObjectMap = ei.id.apply(input);
            if (keyList.length == 1) {
                Object idValue = entityKey.asSingleValue();
                return idObjectMap.get(keyList[0]).equals(idValue);
            } else if (keyList.length > 1) {
                for (String key : keyList) {
                    Object curValue = null;
                    Iterator<OProperty<?>> keyProps = entityKey.asComplexProperties().iterator();
                    while (keyProps.hasNext()) {
                        OProperty<?> keyProp = keyProps.next();
                        if (keyProp.getName().equalsIgnoreCase(key)) {
                            curValue = keyProp.getValue();
                        }
                    }
                    if (curValue == null) {
                        return false;
                    } else if (!idObjectMap.get(key).equals(curValue)) {
                        return false;
                    }
                }
                return true;
            } else {
                return false;
            }
        }
    });
    if (rt == null)
        throw new NotFoundException();
    OEntity oe = toOEntity(ees, rt, queryInfo.expand);
    return Responses.entity(oe);
}

Output:
     final EdmEntitySet ees = getMetadata().getEdmEntitySet(entitySetName);
-    final InMemoryEntityInfo<?, ?> ei = eis.get(entitySetName);
+    final InMemoryEntityInfo<?> ei = eis.get(entitySetName);
     final String[] keyList = ei.keys;


Input:
private void readConfiguration(final String prefix, final boolean output, final Map<String, ARXNode> map, final ZipFile zip) throws IOException, ClassNotFoundException, SAXException {
    final ZipEntry entry = zip.getEntry(prefix + "String_Node_Str");
    if (entry == null) {
        return;
    }
    final ObjectInputStream oos = new ObjectInputStream(zip.getInputStream(entry));
    final ModelConfiguration config = (ModelConfiguration) oos.readObject();
    oos.close();
    if (!output) {
        readInput(config, zip);
        model.setInputConfig(config);
    } else {
        config.setInput(model.getInputConfig().getInput());
        model.setOutputConfig(config);
    }
    readDefinition(config, prefix, zip);
    if (output) {
        final String suppressionString = model.getSuppressionString();
        final int historySize = model.getHistorySize();
        final double snapshotSizeSnapshot = model.getSnapshotSizeSnapshot();
        final double snapshotSizeDataset = model.getSnapshotSizeDataset();
        final boolean removeOutliers = model.getOutputConfig().isRemoveOutliers();
        final Metric<?> metric = config.getMetric();
        final long time = model.getTime();
        final ARXNode optimalNode;
        final ARXNode outputNode;
        if (model.getOptimalNodeAsString() != null) {
            optimalNode = map.get(model.getOptimalNodeAsString());
        } else {
            optimalNode = null;
        }
        if (model.getOutputNodeAsString() != null) {
            outputNode = map.get(model.getOutputNodeAsString());
        } else {
            outputNode = null;
        }
        model.setSelectedNode(outputNode);
        model.setResult(new ARXResult(config.getInput().getHandle(), config.getInput().getDefinition(), lattice, removeOutliers, suppressionString, historySize, snapshotSizeSnapshot, snapshotSizeDataset, metric, model.getOutputConfig().getConfig(), optimalNode, time));
        final ARXAnonymizer f = new ARXAnonymizer();
        model.setAnonymizer(f);
        f.setRemoveOutliers(removeOutliers);
        f.setSuppressionString(suppressionString);
        f.setHistorySize(historySize);
        f.setMaximumSnapshotSizeSnapshot(snapshotSizeSnapshot);
        f.setMaximumSnapshotSizeDataset(snapshotSizeDataset);
    }
}

Output:
         model.setSelectedNode(outputNode);
-        model.setResult(new ARXResult(config.getInput().getHandle(), config.getInput().getDefinition(), lattice, removeOutliers, suppressionString, historySize, snapshotSizeSnapshot, snapshotSizeDataset, metric, model.getOutputConfig().getConfig(), optimalNode, time));
+        model.setResult(new ARXResult(config.getInput().getHandle(), config.getInput().getHandle().getDefinition(), lattice, removeOutliers, suppressionString, historySize, snapshotSizeSnapshot, snapshotSizeDataset, metric, model.getOutputConfig().getConfig(), optimalNode, time));
         final ARXAnonymizer f = new ARXAnonymizer();


Input:
public int checkPermission(String permission, int pid, int uid) {
    if (permission == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    try {
        return ActivityManagerNative.getDefault().checkPermission(permission, pid, uid);
    } catch (RemoteException e) {
        return PackageManager.PERMISSION_DENIED;
    }
}

Output:
     try {
-        return ActivityManagerNative.getDefault().checkPermission(permission, pid, uid);
+        return ActivityManagerNative.getDefault().checkPermissionWithToken(permission, pid, uid, callerToken);
     } catch (RemoteException e) {


Input:
public void classToJava(ClassNode node, StringBuilder buffer, int indent) {
    ClassNode outerNode = (ClassNode) DecompilerContext.getProperty(DecompilerContext.CURRENT_CLASS_NODE);
    DecompilerContext.setProperty(DecompilerContext.CURRENT_CLASS_NODE, node);
    int total_offset_lines = 0;
    BytecodeMappingTracer dummy_tracer = new BytecodeMappingTracer();
    try {
        invokeProcessors(node);
        ClassWrapper wrapper = node.wrapper;
        StructClass cl = wrapper.getClassStruct();
        DecompilerContext.getLogger().startWriteClass(cl.qualifiedName);
        String lineSeparator = DecompilerContext.getNewLineSeparator();
        int start_class_def = buffer.length();
        writeClassDefinition(node, buffer, indent);
        total_offset_lines = buffer.substring(start_class_def).toString().split(lineSeparator, -1).length - 1;
        boolean hasContent = false;
        boolean enumFields = false;
        for (StructField fd : cl.getFields()) {
            boolean hide = fd.isSynthetic() && DecompilerContext.getOption(IFernflowerPreferences.REMOVE_SYNTHETIC) || wrapper.getHiddenMembers().contains(InterpreterUtil.makeUniqueKey(fd.getName(), fd.getDescriptor()));
            if (hide)
                continue;
            boolean isEnum = fd.hasModifier(CodeConstants.ACC_ENUM) && DecompilerContext.getOption(IFernflowerPreferences.DECOMPILE_ENUM);
            if (isEnum) {
                if (enumFields) {
                    buffer.append(',');
                    buffer.append(lineSeparator);
                }
                enumFields = true;
            } else if (enumFields) {
                buffer.append(';');
                buffer.append(lineSeparator);
                buffer.append(lineSeparator);
                enumFields = false;
            }
            fieldToJava(wrapper, cl, fd, buffer, indent + 1, dummy_tracer);
            hasContent = true;
        }
        if (enumFields) {
            buffer.append(';');
            buffer.append(lineSeparator);
        }
        for (StructMethod mt : cl.getMethods()) {
            boolean hide = mt.isSynthetic() && DecompilerContext.getOption(IFernflowerPreferences.REMOVE_SYNTHETIC) || mt.hasModifier(CodeConstants.ACC_BRIDGE) && DecompilerContext.getOption(IFernflowerPreferences.REMOVE_BRIDGE) || wrapper.getHiddenMembers().contains(InterpreterUtil.makeUniqueKey(mt.getName(), mt.getDescriptor()));
            if (hide)
                continue;
            int position = buffer.length();
            if (hasContent) {
                buffer.append(lineSeparator);
            }
            BytecodeMappingTracer method_tracer = new BytecodeMappingTracer(total_offset_lines);
            boolean methodSkipped = !methodToJava(node, mt, buffer, indent + 1, method_tracer);
            if (!methodSkipped) {
                hasContent = true;
                DecompilerContext.getBytecodeSourceMapper().addTracer(cl.qualifiedName, InterpreterUtil.makeUniqueKey(mt.getName(), mt.getDescriptor()), method_tracer);
                total_offset_lines = method_tracer.getCurrentSourceline();
            } else {
                buffer.setLength(position);
            }
        }
        for (ClassNode inner : node.nested) {
            if (inner.type == ClassNode.CLASS_MEMBER) {
                StructClass innerCl = inner.classStruct;
                boolean isSynthetic = (inner.access & CodeConstants.ACC_SYNTHETIC) != 0 || innerCl.isSynthetic();
                boolean hide = isSynthetic && DecompilerContext.getOption(IFernflowerPreferences.REMOVE_SYNTHETIC) || wrapper.getHiddenMembers().contains(innerCl.qualifiedName);
                if (hide)
                    continue;
                if (hasContent) {
                    buffer.append(lineSeparator);
                }
                classToJava(inner, buffer, indent + 1);
                hasContent = true;
            }
        }
        InterpreterUtil.appendIndent(buffer, indent);
        buffer.append('}');
        if (node.type != ClassNode.CLASS_ANONYMOUS) {
            buffer.append(lineSeparator);
        }
    } finally {
        DecompilerContext.setProperty(DecompilerContext.CURRENT_CLASS_NODE, outerNode);
    }
    DecompilerContext.getLogger().endWriteClass();
}

Output:
                 DecompilerContext.getBytecodeSourceMapper().addTracer(cl.qualifiedName, InterpreterUtil.makeUniqueKey(mt.getName(), mt.getDescriptor()), method_tracer);
-                total_offset_lines = method_tracer.getCurrentSourceline();
+                total_offset_lines = (method_tracer.getCurrentSourceLine() + 1);
             } else {


Input:
public void clean() {
    Util.deleteDir(new File(VAR));
    System.out.println("String_Node_Str");
    EmbeddedGraphDatabase neo = Util.startNeoInstance(STORE_LOCATION_DIR);
    ((NeoStoreXaDataSource) neo.getConfig().getPersistenceModule().getPersistenceManager().getPersistenceSource().getXaDataSource()).keepLogicalLogs(true);
    Transaction tx = neo.beginTx();
    try {
        addNode(neo);
        tx.success();
    } finally {
        tx.finish();
    }
    Util.stopNeo(neo);
    Util.copyDir(STORE_LOCATION_DIR, BACKUP_LOCATION_DIR);
}

Output:
     System.out.println("String_Node_Str");
-    EmbeddedGraphDatabase neo = Util.startNeoInstance(STORE_LOCATION_DIR);
-    ((NeoStoreXaDataSource) neo.getConfig().getPersistenceModule().getPersistenceManager().getPersistenceSource().getXaDataSource()).keepLogicalLogs(true);
-    Transaction tx = neo.beginTx();
+    EmbeddedGraphDatabase graphDb = Util.startGraphDbInstance(STORE_LOCATION_DIR);
+    ((NeoStoreXaDataSource) graphDb.getConfig().getPersistenceModule().getPersistenceManager().getPersistenceSource().getXaDataSource()).keepLogicalLogs(true);
+    Transaction tx = graphDb.beginTx();
     try {


Input:
public void testFinished(Description description) throws Exception {
    resultListener.testFinished(description);
    resultListener.testRunFinished(result);
    resultListener = null;
    System.setOut(originalOut);
    System.setErr(originalErr);
    stdOutStream.flush();
    stdErrStream.flush();
    int numFailures = result.getFailureCount();
    String className = description.getClassName();
    String methodName = description.getMethodName();
    if (numFailures < 0) {
        throw new IllegalStateException(String.format("String_Node_Str", className, methodName, numFailures, result.getFailures()));
    }
    Failure failure;
    ResultType type;
    if (assumptionFailures.size() > 0) {
        failure = assumptionFailures.get(0);
        type = ResultType.ASSUMPTION_VIOLATION;
    } else if (numFailures == 0) {
        failure = null;
        type = ResultType.SUCCESS;
    } else {
        failure = result.getFailures().get(0);
        type = ResultType.FAILURE;
    }
    String stdOut = rawStdOutBytes.size() == 0 ? null : rawStdOutBytes.toString(ENCODING);
    String stdErr = rawStdErrBytes.size() == 0 ? null : rawStdErrBytes.toString(ENCODING);
    results.add(new TestResult(className, methodName, result.getRunTime(), type, failure, stdOut, stdErr));
}

Output:
     ResultType type;
-    if (assumptionFailures.size() > 0) {
-        failure = assumptionFailures.get(0);
+    if (assumptionFailure != null) {
+        failure = assumptionFailure;
         type = ResultType.ASSUMPTION_VIOLATION;


Input:
public boolean isMatchTableStillValid() {
    if (!table.isTournament()) {
        int humanPlayers = 0;
        int aiPlayers = 0;
        int validHumanPlayers = 0;
        if (match == null && !(table.getState().equals(TableState.WAITING) || table.getState().equals(TableState.STARTING) || table.getState().equals(TableState.READY_TO_START))) {
            logger.debug("String_Node_Str");
            logger.debug("String_Node_Str" + match.getId() + "String_Node_Str" + match.getName() + "String_Node_Str");
        }
        if (match.isDoneSideboarding()) {
            if (match.getGame() == null) {
                logger.debug("String_Node_Str");
                logger.debug("String_Node_Str" + match.getId() + "String_Node_Str" + match.getName() + "String_Node_Str");
            }
        }
        for (Map.Entry<UUID, UUID> userPlayerEntry : userPlayerMap.entrySet()) {
            MatchPlayer matchPlayer = match.getPlayer(userPlayerEntry.getValue());
            if (matchPlayer == null) {
                logger.debug("String_Node_Str");
                logger.debug("String_Node_Str" + match.getId());
                logger.debug("String_Node_Str" + userPlayerEntry.getKey());
                logger.debug("String_Node_Str" + userPlayerEntry.getValue());
                continue;
            }
            if (matchPlayer.getPlayer().isHuman()) {
                humanPlayers++;
                if (!matchPlayer.hasQuit()) {
                    User user = UserManager.getInstance().getUser(userPlayerEntry.getKey());
                    if (user == null) {
                        logger.debug("String_Node_Str" + matchPlayer.getName());
                        logger.debug("String_Node_Str" + match.getId());
                        logger.debug("String_Node_Str" + userPlayerEntry.getKey());
                        logger.debug("String_Node_Str" + userPlayerEntry.getValue());
                        return false;
                    }
                    validHumanPlayers++;
                }
            } else {
                aiPlayers++;
            }
        }
        return validHumanPlayers >= 2 || validHumanPlayers == humanPlayers || aiPlayers > 1;
    }
    return true;
}

Output:
         int validHumanPlayers = 0;
-        if (match == null && !(table.getState().equals(TableState.WAITING) || table.getState().equals(TableState.STARTING) || table.getState().equals(TableState.READY_TO_START))) {
-            logger.debug("String_Node_Str");
-            logger.debug("String_Node_Str" + match.getId() + "String_Node_Str" + match.getName() + "String_Node_Str");
-        }
-        if (match.isDoneSideboarding()) {
-            if (match.getGame() == null) {
+        if (!(table.getState().equals(TableState.WAITING) || table.getState().equals(TableState.STARTING) || table.getState().equals(TableState.READY_TO_START))) {
+            if (match == null) {
                 logger.debug("String_Node_Str");


Input:
public Result upload(Long folderId) {
    MultipartFormData body = request().body().asMultipartFormData();
    Http.MultipartFormData.FilePart upload = body.getFile("String_Node_Str");
    Folder folder = folderManager.findById(folderId);
    if (!Secured.viewFolder(folder)) {
        return forbidden("String_Node_Str");
    }
    if (upload != null) {
        if (mediaManager.byteAsMB(upload.getFile().length()) > MAX_FILESIZE) {
            return status(REQUEST_ENTITY_TOO_LARGE, "String_Node_Str" + MAX_FILESIZE + "String_Node_Str");
        }
        if (mediaManager.existsInFolder(upload.getFilename(), folder)) {
            return status(CONFLICT, "String_Node_Str");
        }
        Media med = new Media();
        med.title = upload.getFilename();
        med.mimetype = upload.getContentType();
        med.fileName = upload.getFilename();
        med.file = upload.getFile();
        med.owner = Component.currentAccount();
        med.folder = folder;
        med.temporarySender = Component.currentAccount();
        try {
            mediaManager.create(med);
            NotificationService.getInstance().createNotification(med, Media.MEDIA_NEW_MEDIA);
        } catch (Exception e) {
            return internalServerError("String_Node_Str");
        }
        Folder rootFolder = FolderManager.findRoot(folder);
        List<Media> mediaSet = folder.files;
        List<Folder> folderList = folder.folders;
        return created(list.render(mediaSet, folderList, rootFolder.id));
    } else {
        return internalServerError("String_Node_Str");
    }
}

Output:
         }
-        Folder rootFolder = FolderManager.findRoot(folder);
-        List<Media> mediaSet = folder.files;
-        List<Folder> folderList = folder.folders;
-        return created(list.render(mediaSet, folderList, rootFolder.id));
+        return created("String_Node_Str");
     } else {


Input:
private void updateOutputExampleLabel() {
    if (isBlank(destinationField.getText())) {
        outputExampleLabel.setText(getMessage(getRenderDialogOutputExampleLabelKey()));
    }
    File destinationFile = new File(destinationField.getText());
    String name = stripSequenceNumber(stripExtension(destinationFile.getName()));
    int firstFrame = getCurrentAnimation().getFrameOfFirstKeyFrame();
    int lastFrame = getCurrentAnimation().getFrameOfLastKeyFrame();
    int filenameLength = String.valueOf(lastFrame).length();
    final String example = createSequenceFileName(name, firstFrame, filenameLength, "String_Node_Str") + "String_Node_Str" + createSequenceFileName(name, lastFrame, filenameLength, "String_Node_Str");
    SwingUtil.invokeTaskOnEDT(new Runnable() {
        public void run() {
            outputExampleLabel.setText(getMessage(getRenderDialogOutputExampleLabelKey(), example));
        }
    });
}

Output:
     if (isBlank(destinationField.getText())) {
-        outputExampleLabel.setText(getMessage(getRenderDialogOutputExampleLabelKey()));
+        outputExampleLabel.setText(getMessage(getRenderDialogOutputExampleLabelKey(), "String_Node_Str"));
+        return;
     }


Input:
public void testCreatingStreamDefinition2() {
    StreamDefinition streamDefinition = SiddhiCompiler.parseStreamDefinition("String_Node_Str");
    StreamDefinition api = StreamDefinition.id("String_Node_Str").attribute("String_Node_Str", Attribute.Type.STRING).attribute("String_Node_Str", Attribute.Type.INT).attribute("String_Node_Str", Attribute.Type.FLOAT).attribute("String_Node_Str", Attribute.Type.OBJECT);
    Assert.assertEquals(api, streamDefinition);
}

Output:
     StreamDefinition streamDefinition = SiddhiCompiler.parseStreamDefinition("String_Node_Str");
-    StreamDefinition api = StreamDefinition.id("String_Node_Str").attribute("String_Node_Str", Attribute.Type.STRING).attribute("String_Node_Str", Attribute.Type.INT).attribute("String_Node_Str", Attribute.Type.FLOAT).attribute("String_Node_Str", Attribute.Type.OBJECT);
+    StreamDefinition api = StreamDefinition.id("String_Node_Str").attribute("String_Node_Str", Attribute.Type.STRING).attribute("String_Node_Str", Attribute.Type.INT).attribute("String_Node_Str", Attribute.Type.DOUBLE).attribute("String_Node_Str", Attribute.Type.OBJECT);
     Assert.assertEquals(api, streamDefinition);


Input:
public static String jsonStringEnc(String s) {
    int ln = s.length();
    for (int i = 0; i < ln; i++) {
        char c = s.charAt(i);
        if (c == '"' || c == '\\' || c < 0x20 || (c == '/' && i > 0 && s.charAt(i - 1) == '<') || (c == '>' && i > 1 && s.charAt(i - 1) == ']' && s.charAt(i - 2) == ']')) {
            StringBuffer b = new StringBuffer(ln + 4);
            b.append(s.substring(0, i));
            while (true) {
                if (c == '"') {
                    b.append("String_Node_Str");
                } else if (c == '\\') {
                    b.append("String_Node_Str");
                } else if (c == '/' && i > 0 && s.charAt(i - 1) == '<') {
                    b.append("String_Node_Str");
                } else if (c == '>' && i > 1 && s.charAt(i - 1) == ']' && s.charAt(i - 2) == ']') {
                    b.append("String_Node_Str");
                } else if (c < 0x20) {
                    if (c == '\n') {
                        b.append("String_Node_Str");
                    } else if (c == '\r') {
                        b.append("String_Node_Str");
                    } else if (c == '\f') {
                        b.append("String_Node_Str");
                    } else if (c == '\b') {
                        b.append("String_Node_Str");
                    } else if (c == '\t') {
                        b.append("String_Node_Str");
                    } else {
                        b.append("String_Node_Str");
                        int x = c / 0x10;
                        b.append((char) (x < 0xA ? x + '0' : x - 0xA + 'A'));
                        x = c & 0xF;
                        b.append((char) (x < 0xA ? x + '0' : x - 0xA + 'A'));
                    }
                } else {
                    b.append(c);
                }
                i++;
                if (i >= ln) {
                    return b.toString();
                }
                c = s.charAt(i);
            }
        }
    }
    return s;
}

Output:
 public static String jsonStringEnc(String s) {
-    int ln = s.length();
-    for (int i = 0; i < ln; i++) {
-        char c = s.charAt(i);
-        if (c == '"' || c == '\\' || c < 0x20 || (c == '/' && i > 0 && s.charAt(i - 1) == '<') || (c == '>' && i > 1 && s.charAt(i - 1) == ']' && s.charAt(i - 2) == ']')) {
-            StringBuffer b = new StringBuffer(ln + 4);
-            b.append(s.substring(0, i));
-            while (true) {
-                if (c == '"') {
-                    b.append("String_Node_Str");
-                } else if (c == '\\') {
-                    b.append("String_Node_Str");
-                } else if (c == '/' && i > 0 && s.charAt(i - 1) == '<') {
-                    b.append("String_Node_Str");
-                } else if (c == '>' && i > 1 && s.charAt(i - 1) == ']' && s.charAt(i - 2) == ']') {
-                    b.append("String_Node_Str");
-                } else if (c < 0x20) {
-                    if (c == '\n') {
-                        b.append("String_Node_Str");
-                    } else if (c == '\r') {
-                        b.append("String_Node_Str");
-                    } else if (c == '\f') {
-                        b.append("String_Node_Str");
-                    } else if (c == '\b') {
-                        b.append("String_Node_Str");
-                    } else if (c == '\t') {
-                        b.append("String_Node_Str");
-                    } else {
-                        b.append("String_Node_Str");
-                        int x = c / 0x10;
-                        b.append((char) (x < 0xA ? x + '0' : x - 0xA + 'A'));
-                        x = c & 0xF;
-                        b.append((char) (x < 0xA ? x + '0' : x - 0xA + 'A'));
-                    }
-                } else {
-                    b.append(c);
-                }
-                i++;
-                if (i >= ln) {
-                    return b.toString();
-                }
-                c = s.charAt(i);
-            }
-        }
-    }
-    return s;
+    return jsStringEnc(s, true);
 }


Input:
void addList(Node firstInList, boolean isArrayOrFunctionArgument, Context lhsContext) {
    for (Node n = firstInList; n != null; n = n.getNext()) {
        boolean isFirst = n == firstInList;
        if (isFirst) {
            addExpr(n, isArrayOrFunctionArgument ? 1 : 0, lhsContext);
        } else {
            cc.listSeparator();
            addExpr(n, isArrayOrFunctionArgument ? 1 : 0, Context.OTHER);
        }
    }
}

Output:
             cc.listSeparator();
-            addExpr(n, isArrayOrFunctionArgument ? 1 : 0, Context.OTHER);
+            addExpr(n, isArrayOrFunctionArgument ? 1 : 0, getContextForNoInOperator(lhsContext));
         }


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

Output:
     } catch (CoreException e) {
-        CloudFoundryPlugin.logError(e);
+        CloudFoundryPlugin.log(e);
         return false;


Input:
private boolean hasCrossing(PlaneEdge x, PlaneEdge y) {
    String edgeString = x + "String_Node_Str" + y;
    if (y.startX < x.startX) {
        edgeString = y + "String_Node_Str" + x;
    }
    if (handledEdges.contains(edgeString)) {
        return false;
    }
    handledEdges.add(edgeString);
    double d = (x.startX - x.endX) * (y.startY - y.endY) - (x.startY - x.endY) * (y.startX - y.endX);
    if (d == 0) {
        return false;
    }
    double xi = ((y.startX - y.endX) * (x.startX * x.endY - x.startY * x.endX) - (x.startX - x.endX) * (y.startX * y.endY - y.startY * y.endX)) / d;
    double yi = ((y.startY - y.endY) * (x.startX * x.endY - x.startY * x.endX) - (x.startY - x.endY) * (y.startX * y.endY - y.startY * y.endX)) / d;
    if (isBetween(x.startX, x.endX, xi) && isBetween(x.startY, x.endY, yi) && isBetween(y.startX, y.endX, xi) && isBetween(y.startY, y.endY, yi)) {
        return true;
    }
    return false;
}

Output:
     }
-    if (handledEdges.contains(edgeString)) {
-        return false;
+    if (useShortcut) {
+        if (handledEdges.contains(edgeString)) {
+            return false;
+        }
+        handledEdges.add(edgeString);
     }


Input:
private String _generateActorsCode() throws IllegalActionException {
    StringBuffer code = new StringBuffer();
    if (_debugging) {
        _debug("String_Node_Str");
    }
    for (Actor actor : (List<Actor>) ((TypedCompositeActor) _director.getContainer()).deepEntityList()) {
        System.out.println("String_Node_Str" + actor.getFullName() + "String_Node_Str" + actor.getDirector().getFullName());
        CodeGeneratorHelper actorHelper = (CodeGeneratorHelper) _getHelper((NamedObj) actor);
        code.append("String_Node_Str");
        if (actor instanceof CompositeActor) {
            if (actor.getDirector() instanceof ptolemy.domains.sdf.kernel.SDFDirector) {
                for (Actor actor1 : (List<Actor>) ((TypedCompositeActor) actor.getDirector().getContainer()).deepEntityList()) {
                    System.out.println("String_Node_Str" + actor1.getFullName());
                    CodeGeneratorHelper actor1Helper = (CodeGeneratorHelper) _getHelper((NamedObj) actor1);
                    code.append(actor1Helper.generateFireFunctionCode());
                }
            }
        }
        code.append("String_Node_Str");
        String actorFullName = _getActorName(actor);
        String methodSignature = _eol + "String_Node_Str" + actorFullName + _getFireFunctionArguments() + "String_Node_Str" + _eol;
        String srcReference;
        String sinkReference;
        Iterator<IOPort> inputPorts;
        inputPorts = actor.inputPortList().iterator();
        Director dir = actor.getDirector();
        if (actor instanceof CompositeActor) {
            if (dir == null) {
                code.append(methodSignature);
                while (inputPorts.hasNext()) {
                    IOPort inputPort = inputPorts.next();
                    if (_debugging) {
                        _debug("String_Node_Str");
                    }
                    super.generateTransferInputsCode(inputPort, code);
                    super.generateTransferOutputsCode(inputPort, code);
                    code.append(_eol + "String_Node_Str" + _eol);
                }
                code.append("String_Node_Str" + _eol);
            } else if ((dir.getClassName() == "String_Node_Str") || dir.getClassName() == "String_Node_Str") {
                if (actor.getClass().getName().contains("String_Node_Str")) {
                    CodeGeneratorHelper myHelper;
                    StringBuffer actorTransferCode = new StringBuffer("String_Node_Str");
                    while (inputPorts.hasNext()) {
                        IOPort sourcePort = (IOPort) inputPorts.next();
                        String[] channelOffset = { "String_Node_Str", "String_Node_Str" };
                        int i = sourcePort.getWidth();
                        myHelper = (CodeGeneratorHelper) this._getHelper(sourcePort.getContainer());
                        if (i > 1) {
                            for (int j = 0; j < i; j++) {
                                actorTransferCode.append("String_Node_Str");
                            }
                        } else {
                            channelOffset[0] = "String_Node_Str";
                            sinkReference = this.getReference((TypedIOPort) sourcePort, channelOffset, false, true, myHelper);
                            srcReference = this.getDriverReference((TypedIOPort) sourcePort, channelOffset, false, true, myHelper);
                            ArrayList args = new ArrayList();
                            args.add(sinkReference);
                            args.add(srcReference);
                            actorTransferCode.append(_generateBlockCode("String_Node_Str", args));
                        }
                    }
                    code.append(methodSignature);
                    inputPorts = actor.inputPortList().iterator();
                    String[] channelOffset = { "String_Node_Str", "String_Node_Str" };
                    ArrayList args = new ArrayList();
                    while (inputPorts.hasNext()) {
                        IOPort source = inputPorts.next();
                        myHelper = (CodeGeneratorHelper) this._getHelper(source.getContainer());
                        IOPort sink;
                        Iterator<IOPort> sinkPorts = source.deepInsidePortList().iterator();
                        while (sinkPorts.hasNext()) {
                            sink = sinkPorts.next();
                            sinkReference = super.getReference((TypedIOPort) sink, channelOffset, false, true, myHelper);
                            srcReference = super.getReference((TypedIOPort) source, channelOffset, false, true, myHelper);
                            args.add(sinkReference);
                            args.add(srcReference);
                            actorTransferCode.append(_generateBlockCode("String_Node_Str", args));
                        }
                    }
                    code.append(_eol + actorTransferCode.toString() + _eol);
                    code.append(_getActorName(actor) + "String_Node_Str" + _eol);
                    code.append("String_Node_Str" + _eol);
                } else {
                    code.append(methodSignature);
                    code.append(_eol + "String_Node_Str" + _eol);
                    code.append(actorHelper.generateFireFunctionCode2());
                    code.append("String_Node_Str" + _eol);
                }
            } else {
            }
        } else {
            code.append(methodSignature);
            code.append(_eol + "String_Node_Str" + _eol);
            String temp = actorHelper.generateFireFunctionCode2();
            if (temp.length() == 0) {
                code.append(actorHelper.generateFireCode());
            } else {
                code.append(temp);
            }
            code.append("String_Node_Str" + _eol);
        }
    }
    return code.toString();
}

Output:
                 code.append("String_Node_Str" + _eol);
-            } else if ((dir.getClassName() == "String_Node_Str") || dir.getClassName() == "String_Node_Str") {
+            } else if (dir.getClassName().equals("String_Node_Str") || dir.getClassName().equals("String_Node_Str")) {
                 if (actor.getClass().getName().contains("String_Node_Str")) {


Input:
private void lockFile() {
    method = FILE;
    properties = new SortedProperties();
    properties.setProperty("String_Node_Str", String.valueOf(method));
    setUniqueId();
    fs.createDirs(fileName);
    if (!fs.createNewFile(fileName)) {
        waitUntilOld();
        String m2 = load().getProperty("String_Node_Str", FILE);
        if (!m2.equals(FILE)) {
            throw getExceptionFatal("String_Node_Str" + m2, null);
        }
        save();
        sleep(2 * sleep);
        if (!load().equals(properties)) {
            throw getExceptionAlreadyInUse("String_Node_Str");
        }
        fs.delete(fileName);
        if (!fs.createNewFile(fileName)) {
            throw getExceptionFatal("String_Node_Str", null);
        }
    }
    save();
    sleep(SLEEP_GAP);
    if (!load().equals(properties)) {
        fileName = null;
        throw getExceptionFatal("String_Node_Str", null);
    }
    watchdog = new Thread(this);
    watchdog.setName("String_Node_Str" + fileName);
    watchdog.setDaemon(true);
    watchdog.setPriority(Thread.MAX_PRIORITY - 1);
    watchdog.start();
}

Output:
     }
-    watchdog = new Thread(this);
-    watchdog.setName("String_Node_Str" + fileName);
+    watchdog = new Thread(this, "String_Node_Str" + fileName);
     watchdog.setDaemon(true);


Input:
public static Callable<Boolean> getMessageRefreshingTaskToSchedule(User user, String server, String messageId, LocaleService localeService, Locale locale, ServerConfigRepository serverConfigRepository, RaidRepository raidRepository, ClockService clockService, MessageChannel messageChannel, final ExecutorService executorService) {
    final Callable<Boolean> refreshEditThreadTask = () -> {
        final Callable<Boolean> editTask = () -> {
            TimeUnit.SECONDS.sleep(60);
            Config config = serverConfigRepository.getConfigForServer(server);
            if (LOGGER.isTraceEnabled()) {
                LOGGER.trace("String_Node_Str" + Thread.currentThread().getId() + "String_Node_Str" + config.getServer() + "String_Node_Str" + messageId);
            }
            final String messageString = getOverviewMessage(config, localeService, raidRepository, clockService, locale);
            messageChannel.editMessageById(messageId, messageString).queue(m -> {
            }, m -> {
                LOGGER.warn(m.getClass().getSimpleName() + "String_Node_Str" + m.getMessage());
                if (!(m instanceof SocketTimeoutException)) {
                    Config savedConfig = serverConfigRepository.save(config);
                    cleanUp(savedConfig, user, messageId, serverConfigRepository, localeService, messageChannel, locale);
                } else {
                    LOGGER.debug("String_Node_Str" + "String_Node_Str");
                }
            });
            return true;
        };
        do {
            try {
                executorService.submit(editTask).get();
            } catch (InterruptedException | ExecutionException e) {
                LOGGER.warn("String_Node_Str" + e.getMessage() + "String_Node_Str");
                return false;
            }
        } while (true);
    };
    return refreshEditThreadTask;
}

Output:
                     Config savedConfig = serverConfigRepository.save(config);
-                    cleanUp(savedConfig, user, messageId, serverConfigRepository, localeService, messageChannel, locale);
+                    cleanUp(savedConfig, messageId, serverConfigRepository, messageChannel);
+                    throw new OverviewException(m.getMessage());
                 } else {


Input:
private void run(final ITask t) {
    try {
        System.out.println("String_Node_Str" + t + "String_Node_Str");
        t.run();
    } catch (final Exception e) {
        LOG.error("String_Node_Str", e);
    }
}

Output:
     try {
-        System.out.println("String_Node_Str" + t + "String_Node_Str");
+        if (LOG.isTraceEnabled())
+            LOG.trace("String_Node_Str" + t + "String_Node_Str");
         t.run();


Input:
public void run() {
    SimppDataVerifier verifier = new SimppDataVerifier(simppPayload);
    boolean verified = false;
    verified = verifier.verifySource();
    if (!verified)
        return;
    SimppParser parser = null;
    try {
        parser = new SimppParser(verifier.getVerifiedData());
    } catch (SAXException sx) {
        return;
    } catch (IOException iox) {
        return;
    }
    int version = parser.getVersion();
    if (version <= myVersion)
        return;
    SimppManager.this._latestVersion = version;
    SimppManager.this._simppBytes = simppPayload;
    SimppManager.this._propsStream = parser.getPropsData();
    String props = parser.getPropsData();
    SimppSettingsManager.instance().updateSimppSettings(props);
    CapabilitiesVM.updateSimppVersion(version);
    RouterService.getConnectionManager().sendUpdatedCapabilities();
}

Output:
     SimppSettingsManager.instance().updateSimppSettings(props);
-    CapabilitiesVM.updateSimppVersion(version);
+    CapabilitiesVM.reconstructInstance();
     RouterService.getConnectionManager().sendUpdatedCapabilities();


Input:
protected Score computeScore(int total, int success) {
    double[] confidenceInterval = Heuristics.getConfidenceInterval95Wald(total, success);
    double accuracy = (confidenceInterval[0] + confidenceInterval[1]) / 2;
    double confidence = confidenceInterval[1] - confidenceInterval[0];
    return new AxiomScore(accuracy, confidence);
}

Output:
     double confidence = confidenceInterval[1] - confidenceInterval[0];
-    return new AxiomScore(accuracy, confidence);
+    return new AxiomScore(accuracy, confidence, total, success, total - success);
 }


Input:
protected CompletionStage<Result> handleRemoveLineItemError(final Throwable throwable, final Form<RemoveLineItemFormData> removeLineItemForm, final Cart cart) {
    flash(UserFeedback.ERROR, "String_Node_Str");
    return completedFuture(redirect(reverseRouter.showCart(userContext().languageTag())));
}

Output:
 protected CompletionStage<Result> handleRemoveLineItemError(final Throwable throwable, final Form<RemoveLineItemFormData> removeLineItemForm, final Cart cart) {
-    flash(UserFeedback.ERROR, "String_Node_Str");
+    injector.getInstance(UserFeedback.class).addErrors("String_Node_Str");
     return completedFuture(redirect(reverseRouter.showCart(userContext().languageTag())));


Input:
public int compareTo(IndexDefinition def2) {
    int compare = 0;
    IndexOrder[] def2Order = def2.getOrderFields();
    if (orderFields.length > def2Order.length) {
        return 1;
    } else if (orderFields.length < def2Order.length) {
        return -1;
    }
    for (int i = 0; i < orderFields.length; i++) {
        compare = orderFields[i].getName().compareTo(def2Order[i].getName());
        if (compare != 0) {
            return compare;
        }
    }
    FieldOrder[] def2Field = def2.getIndexedFields();
    if (indexedFields.length > def2Field.length) {
        return 1;
    } else if (indexedFields.length < def2Field.length) {
        return -1;
    }
    for (int i = 0; i < indexedFields.length; i++) {
        compare = indexedFields[i].compareTo(def2Field[i]);
        if (compare != 0) {
            return compare;
        }
    }
    return 0;
}

Output:
     for (int i = 0; i < indexedFields.length; i++) {
-        compare = indexedFields[i].compareTo(def2Field[i]);
-        if (compare != 0) {
-            return compare;
+        for (int j = 0; j < def2Field.length; j++) {
+            if (indexedFields[i].getName().equals(def2Field[j].getName())) {
+                matchCount++;
+                break;
+            }
         }


Input:
private static String resolveAbsolutePathFromString(String base, String relativePath) {
    if (base == null || relativePath == null)
        return relativePath;
    try {
        URI uri = new URI(relativePath);
        if (uri.isAbsolute())
            return relativePath;
    } catch (URISyntaxException e) {
    }
    boolean appendDirectorySeparator = false;
    if (base.length() > 0 && relativePath.length() > 0) {
        char lastBaseChar = base.charAt(base.length() - 1);
        char firstRelativeChar = relativePath.charAt(0);
        if (lastBaseChar != '/' && lastBaseChar != File.separatorChar && firstRelativeChar != '/' && firstRelativeChar != File.separatorChar)
            appendDirectorySeparator = true;
    }
    if (appendDirectorySeparator)
        return base + '/' + relativePath;
    return base + relativePath;
}

Output:
         return relativePath;
-    try {
-        URI uri = new URI(relativePath);
-        if (uri.isAbsolute())
-            return relativePath;
-    } catch (URISyntaxException e) {
+    URI uri = URIUtilImpl.resolveAbsolutePath(relativePath);
+    if (uri != null && uri.isAbsolute()) {
+        return relativePath;
     }


Input:
public String get(String name) {
    XObject obj = currentObj;
    if (obj == null)
        obj = getFirstObject(name);
    return (String) obj.getViewProperty(name);
}

Output:
         obj = getFirstObject(name);
-    return (String) obj.getViewProperty(name);
+    return obj.getViewProperty(name);
 }


Input:
public void resume() {
    playerList = state.getPlayerList(state.getActivePlayerId());
    Player player = getPlayer(playerList.get());
    boolean wasPaused = state.isPaused();
    state.resume();
    if (!gameOver(null)) {
        fireInformEvent(new StringBuilder("String_Node_Str").append(state.getTurnNum()).toString());
        if (checkStopOnTurnOption()) {
            return;
        }
        state.getTurn().resumePlay(this, wasPaused);
        if (!isPaused() && !gameOver(null)) {
            endOfTurn();
            player = playerList.getNext(this);
            state.setTurnNum(state.getTurnNum() + 1);
        }
    }
    play(player.getId());
}

Output:
     if (!gameOver(null)) {
-        fireInformEvent(new StringBuilder("String_Node_Str").append(state.getTurnNum()).toString());
+        fireInformEvent("String_Node_Str" + state.getTurnNum());
         if (checkStopOnTurnOption()) {


Input:
protected Integer doInBackground(String... params) {
    int statusCode = 0;
    String noticetrimstr;
    String content = "String_Node_Str";
    if (posts.get(Integer.valueOf(params[2]) - 1).content.startsWith("String_Node_Str")) {
        content = posts.get(Integer.valueOf(params[2]) - 1).content.substring("String_Node_Str".length());
    } else {
        content = posts.get(Integer.valueOf(params[2]) - 1).content;
    }
    noticetrimstr = "String_Node_Str" + posts.get(Integer.valueOf(params[2]) - 1).pid + "String_Node_Str" + posts.get(Integer.valueOf(params[2]) - 1).tid + "String_Node_Str" + posts.get(Integer.valueOf(params[2]) - 1).author + posts.get(Integer.valueOf(params[2]) - 1).time + "String_Node_Str" + content + "String_Node_Str";
    HashMap<String, String> datas = new HashMap<String, String>();
    datas.put("String_Node_Str", params[1]);
    datas.put("String_Node_Str", formhash);
    datas.put("String_Node_Str", "String_Node_Str");
    datas.put("String_Node_Str", "String_Node_Str");
    datas.put("String_Node_Str", "String_Node_Str");
    datas.put("String_Node_Str", "String_Node_Str");
    datas.put("String_Node_Str", "String_Node_Str");
    datas.put("String_Node_Str", noticetrimstr);
    Connection.Response res = Request.execute(params[0], "String_Node_Str", datas, (Map<String, String>) Athority.getSharedPreference().getAll(), Connection.Method.POST);
    statusCode = res.statusCode();
    return statusCode;
}

Output:
     } else {
-        content = posts.get(Integer.valueOf(params[2]) - 1).content;
+        String[] temp = posts.get(Integer.valueOf(params[2]) - 1).content.split("String_Node_Str");
+        content = temp[1];
     }


Input:
public void visitTemplateReportItem(TemplateReportItem obj) {
    DesignVisitor.this.visitTemplateElement(obj.handle(module));
}

Output:
 public void visitTemplateReportItem(TemplateReportItem obj) {
-    DesignVisitor.this.visitTemplateElement(obj.handle(module));
+    DesignVisitor.this.visitTemplateReportItem(obj.handle(module));
 }


Input:
public ROCCurve getROCCurve(String clazz) {
    return this.rocCurves.get(clazz);
}

Output:
 public ROCCurve getROCCurve(String clazz) {
-    return this.rocCurves.get(clazz);
+    return this.ROC.get(clazz);
 }


Input:
public List<Solution> inferSpeciesTree() {
    long startTime = System.currentTimeMillis();
    String[] gtTaxa;
    String[] stTaxa;
    Collapse.CollapseDescriptor cd = null;
    if ((trees == null) || (trees.size() == 0)) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (taxonNameMap != null && taxonNameMap.taxonMap != null) {
        Map<String, String> taxonMap = taxonNameMap.taxonMap;
        String error = Trees.checkMapping(trees, taxonMap);
        if (error != null) {
            throw new RuntimeException("String_Node_Str" + error + "String_Node_Str");
        }
        List temp1 = new LinkedList();
        List temp2 = new LinkedList();
        for (String s : taxonMap.keySet()) {
            temp1.add(s);
            if (!((List) temp2).contains(taxonMap.get(s))) {
                ((List) temp2).add((String) taxonMap.get(s));
            }
        }
        gtTaxa = new String[temp1.size()];
        stTaxa = new String[temp2.size()];
        for (int i = 0; i < gtTaxa.length; i++) {
            gtTaxa[i] = ((String) temp1.get(i));
        }
        for (int i = 0; i < stTaxa.length; i++) {
            stTaxa[i] = ((String) ((List) temp2).get(i));
        }
    } else if (taxonNameMap != null && taxonNameMap.taxonMap == null) {
        Set<String> taxalist = new HashSet<String>();
        Set<String> genelist = new HashSet<String>();
        for (Tree tr : trees) {
            for (TNode node : tr.postTraverse()) {
                genelist.add(node.getName());
                taxalist.add(taxonNameMap.getTaxonName(node.getName()));
            }
        }
        stTaxa = new String[taxalist.size()];
        gtTaxa = new String[genelist.size()];
        int index = 0;
        for (String taxon : taxalist) {
            stTaxa[(index++)] = taxon;
        }
        index = 0;
        for (String gene : genelist) {
            gtTaxa[(index++)] = gene;
        }
    } else {
        cd = null;
        if (rooted & extraTrees == null & taxonNameMap == null && false) {
            cd = doCollapse(trees);
        }
        List<String> taxalist = new ArrayList<String>();
        for (Tree tr : trees) {
            for (TNode node : tr.postTraverse()) {
                if ((node.isLeaf()) && (!taxalist.contains(node.getName()))) {
                    taxalist.add(node.getName());
                }
            }
        }
        stTaxa = new String[taxalist.size()];
        int index = 0;
        for (String taxon : taxalist) {
            stTaxa[(index++)] = taxon;
        }
        gtTaxa = stTaxa;
    }
    System.out.println("String_Node_Str" + stTaxa.length);
    clusters = new HashMap<Integer, Set<Vertex>>(stTaxa.length);
    List<Solution> solutions;
    counter = new DuplicationWeightCounter(gtTaxa, stTaxa, rooted);
    int sigmaN = counter.computeTreeSTBipartitions(trees, taxonNameMap, clusters);
    if (extraTrees != null) {
        counter.addExtraBipartitionsByInput(clusters, extraTrees, taxonNameMap, extrarooted);
    }
    counter.addExtraBipartitionsByHeuristics(clusters);
    if (_print) {
        System.out.println("String_Node_Str" + (System.currentTimeMillis() - startTime) / 1000.0D + "String_Node_Str");
    }
    counter.preCalculateWeights(trees, extraTrees, taxonNameMap);
    if (_print) {
        System.out.println("String_Node_Str" + (System.currentTimeMillis() - startTime) / 1000.0D + "String_Node_Str");
    }
    sigmaNs = optimizeDuploss ? sigmaN + 2 * (stTaxa.length - 1) * trees.size() : sigmaN;
    solutions = findTreesByDP(stTaxa, counter, trees, taxonNameMap);
    if (taxonNameMap == null && rooted && extraTrees == null && false) {
        restoreCollapse(solutions, cd);
    }
    return (List<Solution>) solutions;
}

Output:
         for (Tree tr : trees) {
-            for (TNode node : tr.postTraverse()) {
-                genelist.add(node.getName());
-                taxalist.add(taxonNameMap.getTaxonName(node.getName()));
+            String[] leaves = tr.getLeaves();
+            for (int i = 0; i < leaves.length; i++) {
+                String leaf = leaves[i];
+                genelist.add(leaf);
+                taxalist.add(taxonNameMap.getTaxonName(leaf));
             }


Input:
private void performance(Endpoint ep, PAnalyser p) {
    TreeSet<PResult> res = new TreeSet<PResult>(new Comparator<PResult>() {
        public int compare(PResult o1, PResult o2) {
            int diff = o1.getEndpointResult().getStart().compareTo(o2.getEndpointResult().getStart());
            return diff;
        }
    });
    List<PResult> epRes = _db.getResults(ep, PResult.class, PResult.SCHEMA$);
    for (PResult epres : epRes) {
        res.add(epres);
    }
    if (_onlyLast) {
        p.analyse(res.last());
    } else {
        for (PResult ares : res) {
            p.analyse(ares);
        }
    }
    log.info("String_Node_Str", ep, epRes.size());
}

Output:
     }
-    if (_onlyLast) {
+    log.info("String_Node_Str", epRes.size());
+    if (_onlyLast && epRes.size() != 0) {
         p.analyse(res.last());


Input:
public String createDomainForBankDetails(BankOrderLine bankOrderLine, BankOrder bankOrder) {
    String domain = "String_Node_Str";
    String bankDetailsIds = "String_Node_Str";
    if ((bankOrderLine == null) || (bankOrder == null)) {
        return domain;
    }
    if (bankOrder.getPartnerTypeSelect() == BankOrderRepository.PARTNER_TYPE_COMPANY) {
        if (bankOrderLine.getReceiverCompany() != null) {
            bankDetailsIds = this.getIdStringListFromList(bankOrderLine.getReceiverCompany().getBankDetailsSet());
            if (bankOrderLine.getReceiverCompany().getDefaultBankDetails() != null) {
                bankDetailsIds += bankDetailsIds.equals("String_Node_Str") ? "String_Node_Str" : "String_Node_Str";
                bankDetailsIds += bankOrderLine.getReceiverCompany().getDefaultBankDetails().getId().toString();
            }
        }
    } else if (bankOrderLine.getPartner() != null) {
        bankDetailsIds = this.getIdStringListFromList(bankOrderLine.getPartner().getBankDetailsList());
    }
    if (bankDetailsIds.equals("String_Node_Str")) {
        return domain = "String_Node_Str";
    }
    domain = "String_Node_Str" + bankDetailsIds + "String_Node_Str";
    domain += "String_Node_Str";
    EbicsPartner ebicsPartner = Beans.get(EbicsPartnerRepository.class).all().filter("String_Node_Str", bankOrder.getSenderBankDetails()).fetchOne();
    if (ebicsPartnerIsFiltering(ebicsPartner, bankOrder.getOrderTypeSelect())) {
        domain += "String_Node_Str" + this.getIdStringListFromList(ebicsPartner.getReceiverBankDetailsSet()) + "String_Node_Str";
    }
    if (bankOrder.getBankOrderFileFormat() != null) {
        String acceptedIdentifiers = bankOrder.getBankOrderFileFormat().getBankDetailsTypeSelect();
        if (acceptedIdentifiers != null && !acceptedIdentifiers.equals("String_Node_Str")) {
            domain += "String_Node_Str" + acceptedIdentifiers + "String_Node_Str";
        }
        Currency currency = bankOrder.getBankOrderFileFormat().getCurrency();
        if (!bankOrder.getIsMultiCurrency() && bankOrder.getBankOrderFileFormat().getCurrency() != null) {
            String fileFormatCurrencyId = bankOrder.getBankOrderFileFormat().getCurrency().getId().toString();
            domain += "String_Node_Str" + fileFormatCurrencyId + "String_Node_Str";
        }
    }
    return domain;
}

Output:
         Currency currency = bankOrder.getBankOrderFileFormat().getCurrency();
-        if (!bankOrder.getIsMultiCurrency() && bankOrder.getBankOrderFileFormat().getCurrency() != null) {
-            String fileFormatCurrencyId = bankOrder.getBankOrderFileFormat().getCurrency().getId().toString();
+        if (!bankOrder.getIsMultiCurrency() && currency != null) {
+            String fileFormatCurrencyId = currency.getId().toString();
             domain += "String_Node_Str" + fileFormatCurrencyId + "String_Node_Str";


Input:
private static Pair<ITerm, ITerm> getNextEqualitySubstitution(Collection<IFormula> s, Collection<? extends IFormula> theory, Collection<IFormula> alreadyUsed) {
    Collection<IFormula> candidates = HashSetFactory.make();
    candidates.addAll(s);
    candidates.addAll(theory);
    for (IFormula f : candidates) {
        if (!alreadyUsed.contains(f)) {
            Pair<ITerm, ITerm> substitution = equalitySuggestsSubsitution(f);
            if (substitution != null) {
                alreadyUsed.add(f);
                return substitution;
            }
        }
    }
    return null;
}

Output:
         if (!alreadyUsed.contains(f)) {
-            Pair<ITerm, ITerm> substitution = equalitySuggestsSubsitution(f);
+            Pair<ITerm, ITerm> substitution = equalitySuggestsSubstitution(f);
             if (substitution != null) {


Input:
protected boolean runOnceInPlayThread() {
    InputStream audioStream = null;
    try {
        audioStream = audioSystem.getAudioInputStream(uri);
    } catch (IOException ioex) {
        logger.error("String_Node_Str" + uri, ioex);
    }
    if (audioStream == null)
        return false;
    Codec resampler = null;
    try {
        Format rendererFormat = audioSystem.getFormat(audioStream);
        if (rendererFormat == null)
            return false;
        Format resamplerFormat = null;
        if (renderer.setInputFormat(rendererFormat) == null) {
            resampler = new SpeexResampler();
            resamplerFormat = rendererFormat;
            resampler.setInputFormat(resamplerFormat);
            Format[] supportedResamplerFormats = resampler.getSupportedOutputFormats(resamplerFormat);
            for (Format supportedRendererFormat : renderer.getSupportedInputFormats()) {
                for (Format supportedResamplerFormat : supportedResamplerFormats) {
                    if (supportedRendererFormat.matches(supportedResamplerFormat)) {
                        rendererFormat = supportedRendererFormat;
                        resampler.setOutputFormat(rendererFormat);
                        renderer.setInputFormat(rendererFormat);
                        break;
                    }
                }
            }
        }
        Buffer rendererBuffer = buffer;
        Buffer resamplerBuffer;
        rendererBuffer.setFormat(rendererFormat);
        if (resampler == null)
            resamplerBuffer = null;
        else {
            resamplerBuffer = new Buffer();
            int bufferDataLength = DEFAULT_BUFFER_DATA_LENGTH;
            if (resamplerFormat instanceof AudioFormat) {
                AudioFormat af = (AudioFormat) resamplerFormat;
                int frameSize = af.getSampleSizeInBits() / 8 * af.getChannels();
                bufferDataLength = bufferDataLength / frameSize * frameSize;
            }
            bufferData = new byte[bufferDataLength];
            resamplerBuffer.setData(bufferData);
            resamplerBuffer.setFormat(resamplerFormat);
            resampler.open();
        }
        try {
            renderer.open();
            renderer.start();
            int bufferLength;
            while (isStarted() && ((bufferLength = audioStream.read(bufferData)) != -1)) {
                if (resampler == null) {
                    rendererBuffer.setLength(bufferLength);
                    rendererBuffer.setOffset(0);
                } else {
                    resamplerBuffer.setLength(bufferLength);
                    resamplerBuffer.setOffset(0);
                    rendererBuffer.setLength(0);
                    rendererBuffer.setOffset(0);
                    resampler.process(resamplerBuffer, rendererBuffer);
                }
                while ((renderer.process(rendererBuffer) & Renderer.INPUT_BUFFER_NOT_CONSUMED) == Renderer.INPUT_BUFFER_NOT_CONSUMED) ;
            }
        } catch (IOException ioex) {
            logger.error("String_Node_Str" + uri, ioex);
            return false;
        } catch (ResourceUnavailableException ruex) {
            logger.error("String_Node_Str" + renderer.getClass().getName(), ruex);
            return false;
        }
    } catch (ResourceUnavailableException ruex) {
        if (resampler != null) {
            logger.error("String_Node_Str" + resampler.getClass().getName(), ruex);
            return false;
        }
    } finally {
        try {
            audioStream.close();
        } catch (IOException ioex) {
        }
        if (resampler != null)
            resampler.close();
    }
    return true;
}

Output:
     try {
-        Format rendererFormat = audioSystem.getFormat(audioStream);
+        Format rendererFormat = audioStreamFormat = audioSystem.getFormat(audioStream);
         if (rendererFormat == null)


Input:
public void paintComponent(Graphics g) {
    if (isActive) {
        g.setColor(OVERLAY_COLOR);
        g.fillRect(x + getLeftPadding(), 0, 1, getHeight());
        long time = (long) (x / getPixelScale()) + getTimeOffset();
        FontMetrics metrics = g.getFontMetrics(g.getFont());
        for (Component c : costComponents) {
            if (c instanceof CostOverlay) {
                int compX = getXRelativeToContentPane(c);
                if (compX <= x + getLeftPadding() && compX + c.getWidth() >= x + getLeftPadding()) {
                    List<CostFunctionCapability> costs = ((CostOverlay) c).getCostFunctions();
                    String costString = "String_Node_Str";
                    for (CostFunctionCapability cost : costs) {
                        costString += cost.getValue(time) + "String_Node_Str" + cost.getUnits() + "String_Node_Str";
                    }
                    if (!costString.isEmpty()) {
                        int leftX = x + getLeftPadding();
                        int centerY = getYRelativeToContentPane(c) + c.getHeight() / 2;
                        int width = metrics.stringWidth(costString);
                        int height = metrics.getHeight() * 3 / 2;
                        g.setColor(OVERLAY_COLOR);
                        g.fillRect(leftX, centerY - height / 2, width + 4, height);
                        g.setColor(OVERLAY_TEXT_COLOR);
                        g.drawString(costString, leftX + 2, centerY + metrics.getAscent() / 2 - 1);
                    }
                }
            }
        }
    }
}

Output:
         for (Component c : costComponents) {
-            if (c instanceof CostOverlay) {
+            if (c instanceof CostOverlay && c.isShowing()) {
                 int compX = getXRelativeToContentPane(c);


Input:
public int read(ByteBuffer dst) throws IOException {
    if (this.writeMode) {
        throw new IOException("String_Node_Str");
    }
    if (this.fileChannel == null) {
        try {
            this.fileChannel = this.fileBufferManager.getFileChannelForReading(this.gateID, this.fileID);
        } catch (InterruptedException e) {
            return -1;
        }
        if (this.fileChannel.position() != this.offset) {
            this.fileChannel.position(this.offset);
        }
    }
    if (this.totalBytesRead >= this.bufferSize) {
        return -1;
    }
    final int rem = remaining();
    int bytesRead;
    if (dst.remaining() > rem) {
        final int excess = dst.remaining() - rem;
        dst.limit(dst.limit() - excess);
        bytesRead = this.fileChannel.read(dst);
        dst.limit(dst.limit() + excess);
    } else {
        bytesRead = this.fileChannel.read(dst);
    }
    if (bytesRead < 0) {
        return -1;
    }
    this.totalBytesRead += bytesRead;
    return bytesRead;
}

Output:
         }
-        if (this.fileChannel.position() != this.offset) {
-            this.fileChannel.position(this.offset);
+        if (this.fileChannel.position() != (this.offset + this.totalBytesRead)) {
+            this.fileChannel.position(this.offset + this.totalBytesRead);
         }


Input:
private void setupTable() {
    List<XulComponent> colCollection = getColumns().getChildNodes();
    String[] cols = new String[colCollection.size()];
    SelectionPolicy selectionPolicy = null;
    if ("String_Node_Str".equals(getSeltype())) {
        selectionPolicy = SelectionPolicy.ONE_ROW;
    } else if ("String_Node_Str".equals(getSeltype())) {
        selectionPolicy = SelectionPolicy.MULTI_ROW;
    }
    int[] widths = new int[cols.length];
    int totalFlex = 0;
    for (int i = 0; i < cols.length; i++) {
        totalFlex += colCollection.get(i).getFlex();
    }
    boolean allFlexing = true;
    int totalWidth = 0;
    for (int i = 0; i < cols.length; i++) {
        cols[i] = ((XulTreeCol) colCollection.get(i)).getLabel();
        if (totalFlex > 0 && getWidth() > 0) {
            widths[i] = (int) (getWidth() * ((double) colCollection.get(i).getFlex() / totalFlex));
            totalWidth += widths[i];
        } else if (getColumns().getColumn(i).getWidth() > 0) {
            allFlexing = false;
            widths[i] = getColumns().getColumn(i).getWidth();
            totalWidth += widths[i];
        }
    }
    table = new BaseTable(cols, widths, new BaseColumnComparator[cols.length], selectionPolicy);
    if (getHeight() != 0) {
        table.setHeight(getHeight() + "String_Node_Str");
    } else {
        table.setHeight("String_Node_Str");
    }
    if (getWidth() != 0) {
        table.setWidth(getWidth() + "String_Node_Str");
    } else {
        table.setWidth("String_Node_Str");
    }
    if (allFlexing) {
        table.fillWidth();
    }
    table.addTableSelectionListener(new TableSelectionListener() {
        public void onAllRowsDeselected(SourceTableSelectionEvents sender) {
        }
        public void onCellHover(SourceTableSelectionEvents sender, int row, int cell) {
        }
        public void onCellUnhover(SourceTableSelectionEvents sender, int row, int cell) {
        }
        public void onRowDeselected(SourceTableSelectionEvents sender, int row) {
        }
        public void onRowHover(SourceTableSelectionEvents sender, int row) {
        }
        public void onRowUnhover(SourceTableSelectionEvents sender, int row) {
        }
        public void onRowsSelected(SourceTableSelectionEvents sender, int firstRow, int numRows) {
            try {
                if (getOnselect() != null && getOnselect().trim().length() > 0) {
                    getXulDomContainer().invoke(getOnselect(), new Object[] {});
                }
                Integer[] selectedRows = table.getSelectedRows().toArray(new Integer[table.getSelectedRows().size()]);
                int[] rows = new int[selectedRows.length];
                for (int i = 0; i < selectedRows.length; i++) {
                    rows[i] = selectedRows[i];
                }
                GwtTree.this.setSelectedRows(rows);
                GwtTree.this.colCollection = getColumns().getChildNodes();
                if (GwtTree.this.isShowalleditcontrols() == false) {
                    if (curSelectedRow > -1) {
                        Object[] curSelectedRowOriginal = new Object[getColumns().getColumnCount()];
                        for (int j = 0; j < getColumns().getColumnCount(); j++) {
                            curSelectedRowOriginal[j] = getColumnEditor(j, curSelectedRow);
                        }
                        table.replaceRow(curSelectedRow, curSelectedRowOriginal);
                    }
                    curSelectedRow = rows[0];
                    Object[] newRow = new Object[getColumns().getColumnCount()];
                    for (int j = 0; j < getColumns().getColumnCount(); j++) {
                        newRow[j] = getColumnEditor(j, rows[0]);
                    }
                    table.replaceRow(rows[0], newRow);
                }
            } catch (XulException e) {
                e.printStackTrace();
            }
        }
    });
    setWidgetInPanel(table);
    updateUI();
}

Output:
     }
-    table = new BaseTable(cols, widths, new BaseColumnComparator[cols.length], selectionPolicy);
+    table = new BaseTable(cols, widths, new BaseColumnComparator[cols.length], selectionPolicy, this);
     if (getHeight() != 0) {


Input:
public RuntimeException exception(String failMessage, Object... args) {
    failMessage = format(failMessage, args);
    logger.error(FRAMEWORK, failMessage);
    throwFail().invoke(failMessage);
    return new RuntimeException(failMessage);
}

Output:
 public RuntimeException exception(String failMessage, Object... args) {
-    failMessage = format(failMessage, args);
+    if (args.length > 0)
+        failMessage = format(failMessage, args);
     logger.error(FRAMEWORK, failMessage);


Input:
public void refreshGraph() {
    if (model != null && projection != null) {
        projection.set(Projection.VIEW_WIDTH, this.getWidth());
        projection.set(Projection.VIEW_HEIGHT, this.getHeight());
    }
    synchronized (this) {
        needsRefresh = false;
        TopicMap tm = tmModel.getTopicMap();
        VModel oldModel = model;
        TopicMapModel oldTMModel = tmModel;
        Topic oldRoot = rootTopic;
        ArrayList<VNode> oldNodes = oldModel.getNodes();
        ArrayList<VEdge> oldEdges = oldModel.getEdges();
        remakeModels(tm);
        try {
            for (VNode vnode : oldNodes) {
                Node node = vnode.getNode();
                VNode nn = null;
                if (node instanceof TopicNode) {
                    TopicNode tn = (TopicNode) node;
                    Topic t = tn.getTopic();
                    Topic nt = getNewTopicFor(t, tm);
                    if (nt != null) {
                        nn = model.addNode(tmModel.getNodeFor(nt));
                    }
                } else if (node instanceof AssociationNode) {
                    AssociationNode an = (AssociationNode) node;
                    Association a = an.getAssociation();
                    Association na = getNewAssociationFor(a, tm);
                    if (na != null) {
                        if (na.getRoles().size() != 2) {
                            nn = model.addNode(tmModel.getNodeFor(na));
                        }
                    }
                } else if (node instanceof OccurrenceNode) {
                    OccurrenceNode on = (OccurrenceNode) node;
                    Topic carrier = on.getCarrier();
                    Topic type = on.getType();
                    Topic scope = on.getScope();
                    String o = carrier.getData(type, scope);
                    if (o != null) {
                        nn = model.addNode(tmModel.getNodeFor(carrier, type, scope, o));
                    }
                }
                if (nn != null) {
                    nn.x = vnode.x;
                    nn.y = vnode.y;
                    nn.pinned = vnode.pinned;
                    if (vnode.selected)
                        model.addSelection(nn);
                }
            }
            for (VEdge vedge : oldEdges) {
                Edge edge = vedge.getEdge();
                VEdge ne = null;
                if (edge instanceof AssociationEdge) {
                    AssociationEdge ae = (AssociationEdge) edge;
                    Association a = ae.getAssociation();
                    Association na = getNewAssociationFor(a, tm);
                    if (na != null) {
                        if (a.getRoles().size() == na.getRoles().size()) {
                            if (a.getRoles().size() == 2) {
                                ne = model.addEdge(tmModel.getEdgeFor(na));
                            } else {
                                AssociationNode an = tmModel.getNodeFor(na);
                                VNode vn = model.addNode(an);
                                model.openNode(vn);
                            }
                        }
                    }
                } else if (edge instanceof InstanceEdge) {
                    InstanceEdge ie = (InstanceEdge) edge;
                    Topic instance = ie.getInstance();
                    Topic type = ie.getType();
                    Topic ninstance = getNewTopicFor(instance, tm);
                    Topic ntype = getNewTopicFor(type, tm);
                    if (ninstance != null && ntype != null) {
                        ne = model.addEdge(tmModel.getInstanceEdgeFor(ntype, ninstance));
                    }
                } else if (edge instanceof OccurrenceEdge) {
                    OccurrenceEdge oe = (OccurrenceEdge) edge;
                    Topic carrier = oe.getCarrier();
                    Topic type = oe.getType();
                    Topic scope = oe.getScope();
                    String o = carrier.getData(type, scope);
                    if (o != null) {
                        ne = model.addEdge(tmModel.getOccurrenceEdgeFor(carrier, type, scope, o));
                    }
                }
                if (ne != null) {
                    if (vedge.selected) {
                        model.setSelection(ne);
                    }
                    ne.mouseOver = vedge.mouseOver;
                    ne.labelEdges = vedge.labelEdges;
                    ne.curvature = vedge.curvature;
                }
            }
            rootTopic = getNewTopicFor(oldRoot, tm);
            followNode = null;
        } catch (TopicMapException tme) {
            tme.printStackTrace();
        }
    }
}

Output:
                     Topic scope = on.getScope();
-                    String o = carrier.getData(type, scope);
-                    if (o != null) {
-                        nn = model.addNode(tmModel.getNodeFor(carrier, type, scope, o));
+                    Topic ncarrier = getNewTopicFor(carrier, tm);
+                    Topic ntype = getNewTopicFor(type, tm);
+                    Topic nscope = getNewTopicFor(scope, tm);
+                    if (ncarrier != null && ntype != null && nscope != null) {
+                        String o = ncarrier.getData(ntype, nscope);
+                        if (o != null) {
+                            nn = model.addNode(tmModel.getNodeFor(ncarrier, ntype, nscope, o));
+                        }
                     }


Input:
public void setBlueprint(MinechemBlueprint blueprint) {
    this.blueprint = blueprint;
    this.structure = blueprint.getResultStructure();
    this.offsetX = xCoord - blueprint.getManagerPosX();
    this.offsetY = xCoord - blueprint.getManagerPosY();
    this.offsetZ = xCoord - blueprint.getManagerPosZ();
}

Output:
     this.offsetX = xCoord - blueprint.getManagerPosX();
-    this.offsetY = xCoord - blueprint.getManagerPosY();
-    this.offsetZ = xCoord - blueprint.getManagerPosZ();
+    this.offsetY = yCoord - blueprint.getManagerPosY();
+    this.offsetZ = zCoord - blueprint.getManagerPosZ();
 }


Input:
public Date getTimeParameter(final String name, final Date defaultValue) throws IllegalArgumentException {
    if (parameters.containsKey(name)) {
        final String parameterStringValue = parameters.get(name).getAsString();
        if (TextUtils.isEmpty(parameterStringValue)) {
            return defaultValue;
        }
        try {
            return ParametersConverter.parseTime(name);
        } catch (final ParseException pe) {
            throw new IllegalArgumentException(String.format(DATE_FORMAT_ERROR_MESSAGE, name, parameterStringValue), pe);
        }
    }
    return defaultValue;
}

Output:
         try {
-            return ParametersConverter.parseTime(name);
+            return ParametersConverter.parseTime(parameterStringValue);
         } catch (final ParseException pe) {


Input:
public void send() {
    rabbitTemplate.convertAndSend(CommonConstant.LOG_QUEUE, "String_Node_Str");
}

Output:
 public void send() {
-    rabbitTemplate.convertAndSend(CommonConstant.LOG_QUEUE, "String_Node_Str");
+    try {
+        rabbitTemplate.convertAndSend(CommonConstant.LOG_QUEUE, "String_Node_Str");
+    } catch (Exception connectException) {
+        logger.error("String_Node_Str", connectException);
+    }
 }


Input:
private void init() throws Exception {
    ProducerConfiguration configuration = configService.getConfiguration();
    ProducerRegistrationRequirements registrationRequirements = configuration.getRegistrationRequirements();
    getUIFormCheckBoxInput(REG_REQUIRED_FOR_DESCRIPTION).setValue(registrationRequirements.isRegistrationRequiredForFullDescription());
    getUIFormCheckBoxInput(STRICT_MODE).setValue(configuration.isUsingStrictMode());
    boolean registrationRequired = registrationRequirements.isRegistrationRequired();
    getUIFormCheckBoxInput(REQUIRES_REGISTRATION).setValue(registrationRequired);
    if (registrationDetails != null) {
        removeChild(registrationDetails.getClass());
    }
    if (registrationRequired) {
        registrationDetails = new UIWSRPFormInputSet(REGISTRATION_DETAILS);
        UIFormInputBase<String> policyInput = new UIFormStringInput(POLICY_CLASS, POLICY_CLASS, null);
        addUIFormInput(policyInput);
        RegistrationPolicy policy = registrationRequirements.getPolicy();
        String policyClassName = policy.getClass().getName();
        policyInput.setValue(policyClassName);
        if (ProducerRegistrationRequirements.DEFAULT_POLICY_CLASS_NAME.equals(policyClassName)) {
            UIFormInputBase<String> validatorInput = new UIFormStringInput(VALIDATOR_CLASS, VALIDATOR_CLASS, null);
            registrationDetails.addUIFormInput(validatorInput);
            DefaultRegistrationPolicy defaultPolicy = (DefaultRegistrationPolicy) policy;
            validatorInput.setValue(defaultPolicy.getValidator().getClass().getName());
        }
        Map<QName, RegistrationPropertyDescription> regProps = configuration.getRegistrationRequirements().getRegistrationProperties();
        UIGrid uiGrid = registrationDetails.addChild(UIGrid.class, "String_Node_Str", null);
        uiGrid.configure("String_Node_Str", FIELDS, SELECT_ACTIONS);
        uiGrid.getUIPageIterator().setId("String_Node_Str");
        addChild(uiGrid.getUIPageIterator());
        uiGrid.getUIPageIterator().setRendered(false);
        LazyPageList propertyList = createPageList(getPropertyList(regProps));
        uiGrid.getUIPageIterator().setPageList(propertyList);
        addUIFormInput(registrationDetails);
        registrationDetails.setRendered(true);
    }
}

Output:
     ProducerRegistrationRequirements registrationRequirements = configuration.getRegistrationRequirements();
-    getUIFormCheckBoxInput(REG_REQUIRED_FOR_DESCRIPTION).setValue(registrationRequirements.isRegistrationRequiredForFullDescription());
-    getUIFormCheckBoxInput(STRICT_MODE).setValue(configuration.isUsingStrictMode());
+    regReqForDesc.setValue(registrationRequirements.isRegistrationRequiredForFullDescription());
+    strictMode.setValue(configuration.isUsingStrictMode());
     boolean registrationRequired = registrationRequirements.isRegistrationRequired();


Input:
public void deleteInstance(ServerContext context, String resourceId, DeleteRequest request, ResultHandler<Resource> handler) {
    try {
        final ConnectorFacade facade = getConnectorFacade0(handler, DeleteApiOp.class);
        if (null == facade) {
            return;
        }
        final Uid uid = request.getRevision() != null ? new Uid(resourceId, request.getRevision()) : new Uid(resourceId);
        Resource before = getCurrentResource(facade, uid, null);
        OperationOptions operationOptions = operations.get(DeleteApiOp.class).build(jsonConfiguration, objectClassInfoHelper).build();
        facade.delete(objectClassInfoHelper.getObjectClass(), uid, operationOptions);
        JsonValue result = new JsonValue(new HashMap<String, Object>());
        result.put(Resource.FIELD_CONTENT_ID, uid.getUidValue());
        if (null != uid.getRevision()) {
            result.put(Resource.FIELD_CONTENT_REVISION, uid.getRevision());
        }
        activityLogger.log(context, RequestType.DELETE, "String_Node_Str", getSource(objectClass, uid.getUidValue()), before.getContent(), null, Status.SUCCESS);
        handler.handleResult(new Resource(uid.getUidValue(), uid.getRevision(), result));
    } catch (ResourceException e) {
        handler.handleError(e);
    } catch (ConnectorException e) {
        handleConnectorException(context, request, e, resourceId, null, null, handler, activityLogger);
    } catch (JsonValueException e) {
        handler.handleError(new BadRequestException(e.getMessage(), e));
    } catch (Exception e) {
        handler.handleError(new InternalServerErrorException(e.getMessage(), e));
    }
}

Output:
     } catch (ConnectorException e) {
-        handleConnectorException(context, request, e, resourceId, null, null, handler, activityLogger);
+        handleConnectorException(context, request, e, getSource(objectClass), resourceId, null, null, handler, activityLogger);
     } catch (JsonValueException e) {