Input:
public Object applyConversions(int index, String stringValue) {
    List<Conversion<String, ?>> conversions = conversionsByIndex.get(index);
    if (conversions != null) {
        for (Conversion<String, ?> conversion : conversions) {
            Object result = null;
            try {
                result = conversion.execute(stringValue);
                if (result == null || result instanceof String) {
                    stringValue = (String) result;
                } else {
                    return result;
                }
            } catch (Exception ex) {
                throw new IllegalStateException("String_Node_Str" + result + "String_Node_Str" + conversion.getClass().getName(), ex);
            }
        }
    }
    return stringValue;
}

Output:
 public Object applyConversions(int index, String stringValue) {
-    List<Conversion<String, ?>> conversions = conversionsByIndex.get(index);
+    List<Conversion<?, ?>> conversions = conversionsByIndex.get(index);
     if (conversions != null) {


Input:
public boolean addXsiTypeAndClassIndicatorIfRequired(XMLRecord record, XMLDescriptor xmlDescriptor, XMLDescriptor referenceDescriptor, XMLField xmlField, boolean addToNamespaceResolver) {
    if (descriptor.hasInheritance() && !xsiTypeIndicatorField) {
        xmlDescriptor.getInheritancePolicy().addClassIndicatorFieldToRow(record);
        return true;
    }
    QName leafType = null;
    if (xmlField != null) {
        leafType = xmlField.getLeafElementType();
        XMLSchemaReference xmlRef = xmlDescriptor.getSchemaReference();
        if (xmlRef != null) {
            if (leafType == null) {
                if (xmlRef.getType() == XMLSchemaReference.ELEMENT) {
                    return false;
                }
                if (referenceDescriptor == null) {
                    writeXsiTypeAttribute(xmlDescriptor, record, xmlRef, addToNamespaceResolver);
                    return true;
                }
            } else if (((xmlRef.getType() == XMLSchemaReference.COMPLEX_TYPE) || (xmlRef.getType() == XMLSchemaReference.SIMPLE_TYPE)) && xmlRef.getSchemaContext() != null && xmlRef.isGlobalDefinition()) {
                QName ctxQName = xmlRef.getSchemaContextAsQName(xmlDescriptor.getNamespaceResolver());
                if (!ctxQName.equals(leafType)) {
                    writeXsiTypeAttribute(xmlDescriptor, record, xmlRef, addToNamespaceResolver);
                    return true;
                }
            }
        }
    }
    if (referenceDescriptor != null && referenceDescriptor == xmlDescriptor) {
        return false;
    }
    if (xmlDescriptor.hasInheritance() && !xmlDescriptor.getInheritancePolicy().isRootParentDescriptor()) {
        InheritancePolicy inheritancePolicy = xmlDescriptor.getInheritancePolicy();
        XMLField indicatorField = (XMLField) inheritancePolicy.getClassIndicatorField();
        if (indicatorField != null && xsiTypeIndicatorField) {
            Object classIndicatorValueObject = inheritancePolicy.getClassIndicatorMapping().get(xmlDescriptor.getJavaClass());
            String classIndicatorUri = null;
            String classIndicatorLocal = null;
            String classIndicatorPrefix = null;
            if (classIndicatorValueObject instanceof QName) {
                QName classIndicatorQName = (QName) classIndicatorValueObject;
                classIndicatorUri = classIndicatorQName.getNamespaceURI();
                classIndicatorLocal = classIndicatorQName.getLocalPart();
                classIndicatorPrefix = classIndicatorQName.getPrefix();
            } else {
                String classIndicatorValue = (String) inheritancePolicy.getClassIndicatorMapping().get(xmlDescriptor.getJavaClass());
                int nsindex = classIndicatorValue.indexOf(XMLConstants.COLON);
                String prefix = null;
                if (nsindex != -1) {
                    classIndicatorLocal = classIndicatorValue.substring(nsindex + 1);
                    prefix = classIndicatorValue.substring(0, nsindex);
                } else {
                    classIndicatorLocal = classIndicatorValue;
                }
                classIndicatorUri = xmlDescriptor.getNonNullNamespaceResolver().resolveNamespacePrefix(prefix);
            }
            if (leafType == null || !(leafType.getLocalPart().equals(classIndicatorLocal)) || (classIndicatorUri == null && (leafType.getNamespaceURI() != null && leafType.getNamespaceURI().length() > 0)) || (classIndicatorUri != null && !classIndicatorUri.equals(leafType.getNamespaceURI()))) {
                if (inheritancePolicy.hasClassExtractor()) {
                    inheritancePolicy.addClassIndicatorFieldToRow(record);
                } else {
                    writeXsiTypeAttribute(xmlDescriptor, record, classIndicatorUri, classIndicatorLocal, classIndicatorPrefix, addToNamespaceResolver);
                }
                return true;
            }
            return false;
        }
    }
    return false;
}

Output:
                 if (referenceDescriptor == null) {
-                    writeXsiTypeAttribute(xmlDescriptor, record, xmlRef, addToNamespaceResolver);
+                    writeXsiTypeAttribute(xmlDescriptor, record, xmlRef, isRootElement);
                     return true;


Input:
public List<Usage> deleteCsarWithElements(Csar csar) {
    List<Usage> relatedResourceList = getCsarRelatedResourceList(csar);
    if (relatedResourceList.isEmpty()) {
        indexerService.deleteElements(csar.getName(), csar.getVersion(), csar.getHash());
        csarDAO.delete(Csar.class, csar.getId());
        alienRepository.removeCSAR(csar.getWorkspace(), csar.getName(), csar.getVersion());
    }
    return relatedResourceList;
}

Output:
     if (relatedResourceList.isEmpty()) {
-        indexerService.deleteElements(csar.getName(), csar.getVersion(), csar.getHash());
-        csarDAO.delete(Csar.class, csar.getId());
-        alienRepository.removeCSAR(csar.getWorkspace(), csar.getName(), csar.getVersion());
+        deleteCsar(csar);
     }


Input:
private String formatItemText(Object oText) throws ChartException {
    String str;
    if (snFormat != null) {
        str = snFormat.format(oText);
    } else {
        str = format(oText);
    }
    return lgData.rtc.externalizedMessage(str);
}

Output:
     String str;
-    if (snFormat != null) {
+    if (snFormat != SeriesNameFormat.DEFAULT_FORMAT) {
         str = snFormat.format(oText);


Input:
public void processKeyboardInput(int key) {
    for (UIDisplayElement screen : _renderer.getDisplayElements()) {
        if (screenCanFocus(screen)) {
            screen.processKeyboardInput(key);
        }
    }
}

Output:
     for (UIDisplayElement screen : _renderer.getDisplayElements()) {
-        if (screenCanFocus(screen)) {
+        if (screen.isVisible() && !screen.isOverlay()) {
             screen.processKeyboardInput(key);


Input:
public static void merge(org.eclipse.microprofile.openapi.annotations.headers.Header header, Map<String, Header> headers, boolean override, Map<String, Schema> currentSchemas) {
    if (isAnnotationNull(header)) {
        return;
    }
    String headerName = header.name();
    if (header.name() == null || header.name().isEmpty()) {
        headerName = UNKNOWN_NAME;
    }
    Header model = headers.getOrDefault(headerName, new HeaderImpl());
    headers.put(headerName, model);
    merge(header, model, override, currentSchemas);
    if (model.getRef() != null) {
        headers.remove(headerName);
        headers.put(model.getRef().split("String_Node_Str")[3], model);
    }
}

Output:
     if (header.name() == null || header.name().isEmpty()) {
-        headerName = UNKNOWN_NAME;
+        headerName = UNKNOWN_ELEMENT_NAME;
     }


Input:
public void execute(Tuple input) {
    List<PacketInfo> packetInfoList = null;
    try {
        packetInfoList = PcapParser.parse(input.getBinary(0));
        if (packetInfoList != null) {
            for (PacketInfo packetInfo : packetInfoList) {
                JSONObject message = new JSONObject();
                message.put("String_Node_Str", packetInfo.getKey());
                message.put("String_Node_Str", packetInfo.getJsonIndexDoc());
                collector.emit("String_Node_Str", new Values(message));
                collector.emit("String_Node_Str", new Values(packetInfo.getJsonDoc(), packetInfo.getKey()));
                collector.emit("String_Node_Str", new Values(packetInfo.getKey(), (packetInfo.getPacketHeader().getTsSec() * secMultiplier + packetInfo.getPacketHeader().getTsUsec() * microSecMultiplier), input.getBinary(0)));
            }
        }
    } catch (Exception e) {
        collector.fail(input);
        e.printStackTrace();
        LOG.error("String_Node_Str", e);
        String error_as_string = org.apache.commons.lang.exception.ExceptionUtils.getStackTrace(e);
        JSONObject error = ErrorGenerator.generateErrorMessage("String_Node_Str" + input.getBinary(0), error_as_string);
        collector.emit("String_Node_Str", new Values(error));
        return;
    }
    collector.ack(input);
}

Output:
                 message.put("String_Node_Str", packetInfo.getKey());
-                message.put("String_Node_Str", packetInfo.getJsonIndexDoc());
-                collector.emit("String_Node_Str", new Values(message));
+                if (header.containsKey("String_Node_Str")) {
+                    String tmp = header.get("String_Node_Str").toString();
+                    header.remove("String_Node_Str");
+                    header.put("String_Node_Str", tmp);
+                }
+                if (header.containsKey("String_Node_Str")) {
+                    String tmp = header.get("String_Node_Str").toString();
+                    header.remove("String_Node_Str");
+                    header.put("String_Node_Str", tmp);
+                }
+                if (header.containsKey("String_Node_Str")) {
+                    String tmp = header.get("String_Node_Str").toString();
+                    header.remove("String_Node_Str");
+                    header.put("String_Node_Str", tmp);
+                }
+                if (message.containsKey("String_Node_Str")) {
+                    String tmp = header.get("String_Node_Str").toString();
+                    header.remove("String_Node_Str");
+                    header.put("String_Node_Str", tmp);
+                }
+                if (message.containsKey("String_Node_Str")) {
+                    String tmp = header.get("String_Node_Str").toString();
+                    header.remove("String_Node_Str");
+                    header.put("String_Node_Str", tmp);
+                }
+                message.put("String_Node_Str", header);
+                collector.emit("String_Node_Str", new Values(packetInfo.getKey(), message));
                 collector.emit("String_Node_Str", new Values(packetInfo.getJsonDoc(), packetInfo.getKey()));


Input:
private boolean openStreamsForResume() {
    final URL theURL = getRemoteFileURL();
    try {
        remoteFileURL = new URL(theURL.toString());
        final String urlString = getRemoteFileURL().toString();
        httpClient.getHttpConnectionManager().getParams().setSoTimeout(DEFAULT_CONNECTION_TIMEOUT);
        httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(DEFAULT_CONNECTION_TIMEOUT);
        setupAuthentication(urlString);
        setupHostAndPort(urlString);
        getMethod = new GzipGetMethod(urlString);
        getMethod.setFollowRedirects(true);
        setResumeRequestHeaderValues();
        final int code = httpClient.executeMethod(getMethod);
        if (code == HttpURLConnection.HTTP_PARTIAL || code == HttpURLConnection.HTTP_OK) {
            getResumeResponseHeaderValues();
            setInputStream(getMethod.getResponseBodyAsStream());
            this.paused = false;
            fireReceiveResumedEvent();
        } else if (code == HttpURLConnection.HTTP_NOT_FOUND) {
            getMethod.releaseConnection();
            throw new FileNotFoundException(urlString);
        } else if (code == HttpURLConnection.HTTP_UNAUTHORIZED || code == HttpURLConnection.HTTP_FORBIDDEN) {
            getMethod.getResponseBody();
            getMethod.releaseConnection();
            throw new IncomingFileTransferException(Messages.HttpClientRetrieveFileTransfer_Unauthorized);
        } else if (code == HttpURLConnection.HTTP_PROXY_AUTH) {
            getMethod.releaseConnection();
            throw new LoginException(Messages.HttpClientRetrieveFileTransfer_Proxy_Auth_Required);
        } else {
            getMethod.releaseConnection();
            throw new IOException(NLS.bind(Messages.HttpClientRetrieveFileTransfer_ERROR_GENERAL_RESPONSE_CODE, new Integer(code)));
        }
        return true;
    } catch (final Exception e) {
        this.exception = e;
        this.done = true;
        hardClose();
        fireTransferReceiveDoneEvent();
        return false;
    }
}

Output:
             getResumeResponseHeaderValues();
-            setInputStream(getMethod.getResponseBodyAsStream());
+            setInputStream(((GzipGetMethod) getMethod).getResponseBodyAsUnzippedStream());
             this.paused = false;


Input:
public void setState(int uid, int state, String message) {
    AppHolder app = mAppsByUid.get(uid);
    app.message = message;
    if (mActionId == R.string.menu_import && mAppsWaiting.contains(app)) {
        mAppsWaiting.remove(app);
        mAppsDone.add(app);
        this.setNotifyOnChange(false);
        this.clear();
        this.addAll(mAppsDone);
        this.addAll(mAppsWaiting);
    }
    app.state = state;
    changeNotifier.setScrollTo(mAppAdapter.getPosition(app));
    runOnUiThread(changeNotifier);
}

Output:
     app.state = state;
-    changeNotifier.setScrollTo(mAppAdapter.getPosition(app));
+    changeNotifier.setScrollTo(app);
     runOnUiThread(changeNotifier);


Input:
public void run() {
    try {
        updateProgressListener(EProgressState.LOADING, 0.1f);
        DataOutputStream replayFileStream = createReplayFileStream();
        IGameClock gameClock = MatchConstants.clock = networkConnector.getGameClock();
        gameClock.setReplayLogStream(replayFileStream);
        RandomSingleton.load(randomSeed);
        Movable.resetState();
        updateProgressListener(EProgressState.LOADING_MAP, 0.3f);
        Thread imagePreloader = ImageProvider.getInstance().startPreloading();
        MainGridWithUiSettings gridWithUiState = mapcreator.loadMainGrid(availablePlayers);
        mainGrid = gridWithUiState.getMainGrid();
        PlayerState playerState = gridWithUiState.getPlayerState(playerId);
        RescheduleTimer.schedule(gameClock);
        updateProgressListener(EProgressState.LOADING_IMAGES, 0.7f);
        statistics = new GameStatistics(gameClock);
        mainGrid.initForPlayer(playerId, playerState.getFogOfWar());
        mainGrid.startThreads();
        imagePreloader.join();
        waitForStartingGameListener();
        updateProgressListener(EProgressState.WAITING_FOR_OTHER_PLAYERS, 0.98f);
        networkConnector.setStartFinished(true);
        waitForAllPlayersStartFinished(networkConnector);
        final IMapInterfaceConnector connector = startingGameListener.startFinished(this);
        connector.loadUIState(playerState.getUiState());
        GuiInterface guiInterface = new GuiInterface(connector, gameClock, networkConnector.getTaskScheduler(), mainGrid.getGuiInputGrid(), this, playerId, multiplayer);
        if (replayFileInputStream != null) {
            gameClock.loadReplayLogFromStream(replayFileInputStream);
        }
        gameClock.startExecution();
        gameRunning = true;
        synchronized (stopMutex) {
            while (!stopped) {
                try {
                    stopMutex.wait();
                } catch (InterruptedException e) {
                }
            }
        }
        networkConnector.shutdown();
        gameClock.stopExecution();
        connector.shutdown();
        mainGrid.stopThreads();
        guiInterface.stop();
        RescheduleTimer.stop();
        Movable.resetState();
        Building.dropAllBuildings();
    } catch (MapLoadException e) {
        e.printStackTrace();
        reportFail(EGameError.MAPLOADING_ERROR, e);
    } catch (Exception e) {
        e.printStackTrace();
        reportFail(EGameError.UNKNOWN_ERROR, e);
    }
    if (exitListener != null) {
        exitListener.gameExited(this);
    }
}

Output:
         mainGrid.startThreads();
-        imagePreloader.join();
+        if (imagePreloader != null)
+            imagePreloader.join();
         waitForStartingGameListener();


Input:
public File getLocalFile(String pdbId) {
    LinkedList<File> searchdirs = new LinkedList<File>();
    String middle = pdbId.substring(1, 3).toLowerCase();
    File splitdir = new File(splitDirPath, middle);
    searchdirs.add(splitdir);
    if (getObsoleteBehavior() == ObsoleteBehavior.FETCH_OBSOLETE) {
        File obsdir = new File(obsoleteDirPath, middle);
        searchdirs.add(obsdir);
    }
    String[] prefixes = new String[] { "String_Node_Str", "String_Node_Str" };
    for (File searchdir : searchdirs) {
        for (String prefix : prefixes) {
            for (String ex : getExtensions()) {
                File f = new File(searchdir, prefix + pdbId + ex);
                if (f.exists()) {
                    return f;
                }
            }
        }
    }
    return null;
}

Output:
             for (String ex : getExtensions()) {
-                File f = new File(searchdir, prefix + pdbId + ex);
+                File f = new File(searchdir, prefix + pdbId.toLowerCase() + ex);
                 if (f.exists()) {


Input:
protected static void logOutput(Configuration configuration, Logger log, String output, boolean error) {
    if (Strings.notEmpty(output)) {
        String[] lines = output.split("String_Node_Str");
        for (String line : lines) {
            if (error) {
                configuration.info(log, line);
            } else {
                configuration.warn(log, line);
            }
        }
    }
}

Output:
             } else {
-                configuration.warn(log, line);
+                configuration.error(log, line);
             }


Input:
public String toString() {
    return "String_Node_Str" + "String_Node_Str" + keySeconds.size() + "String_Node_Str" + secondObjects.keySet() + '}';
}

Output:
 public String toString() {
-    return "String_Node_Str" + "String_Node_Str" + keySeconds.size() + "String_Node_Str" + secondObjects.keySet() + '}';
+    return "String_Node_Str" + "String_Node_Str" + keySeconds.size() + "String_Node_Str" + secondObjects.size() + "String_Node_Str" + secondObjects.keySet() + '}';
 }


Input:
public Collection<TopLevelItem> getItems() {
    List<TopLevelItem> result = new ArrayList<>();
    for (ComponentSpec componentSpec : componentSpecs) {
        AbstractProject project = ProjectUtil.getProject(componentSpec.getFirstJob());
        List<AbstractProject<?, ?>> projects = ProjectUtil.getAllDownstreamProjects(project);
        for (AbstractProject<?, ?> abstractProject : projects) {
            result.add(getItem(abstractProject.getName()));
        }
    }
    return result;
}

Output:
         AbstractProject project = ProjectUtil.getProject(componentSpec.getFirstJob());
-        List<AbstractProject<?, ?>> projects = ProjectUtil.getAllDownstreamProjects(project);
+        Collection<AbstractProject<?, ?>> projects = ProjectUtil.getAllDownstreamProjects(project).values();
         for (AbstractProject<?, ?> abstractProject : projects) {


Input:
public void addMainParameters(final List<ElementParameter> listParam, INode node) {
    ElementParameter param;
    param = new ElementParameter(node);
    param.setName(EParameterName.UNIQUE_NAME.getName());
    param.setValue("String_Node_Str");
    param.setDisplayName(EParameterName.UNIQUE_NAME.getDisplayName());
    param.setFieldType(EParameterFieldType.TEXT);
    param.setCategory(EComponentCategory.ADVANCED);
    param.setNumRow(1);
    param.setReadOnly(true);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.COMPONENT_NAME.getName());
    param.setValue(getName());
    param.setDisplayName(EParameterName.COMPONENT_NAME.getDisplayName());
    param.setFieldType(EParameterFieldType.TEXT);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(1);
    param.setReadOnly(true);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.VERSION.getName());
    param.setValue("String_Node_Str");
    param.setDisplayName(EParameterName.VERSION.getDisplayName());
    param.setFieldType(EParameterFieldType.TEXT);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(2);
    param.setReadOnly(true);
    param.setRequired(false);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.FAMILY.getName());
    param.setValue(getOriginalFamilyName());
    param.setDisplayName(EParameterName.FAMILY.getDisplayName());
    param.setFieldType(EParameterFieldType.TEXT);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(3);
    param.setReadOnly(true);
    param.setRequired(false);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.STARTABLE.getName());
    param.setValue(new Boolean(canStart()));
    param.setDisplayName(EParameterName.STARTABLE.getDisplayName());
    param.setFieldType(EParameterFieldType.CHECK);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(5);
    param.setReadOnly(true);
    param.setRequired(false);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.SUBTREE_START.getName());
    param.setValue(new Boolean(canStart()));
    param.setDisplayName(EParameterName.SUBTREE_START.getDisplayName());
    param.setFieldType(EParameterFieldType.CHECK);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(5);
    param.setReadOnly(true);
    param.setRequired(false);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.END_OF_FLOW.getName());
    param.setValue(new Boolean(canStart()));
    param.setDisplayName(EParameterName.END_OF_FLOW.getDisplayName());
    param.setFieldType(EParameterFieldType.CHECK);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(5);
    param.setReadOnly(true);
    param.setRequired(false);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.ACTIVATE.getName());
    param.setValue(new Boolean(true));
    param.setDisplayName(EParameterName.ACTIVATE.getDisplayName());
    param.setFieldType(EParameterFieldType.CHECK);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(5);
    param.setReadOnly(false);
    param.setRequired(false);
    param.setDefaultValue(param.getValue());
    param.setShow(true);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.DUMMY.getName());
    param.setValue(Boolean.FALSE);
    param.setDefaultValue(Boolean.FALSE);
    param.setDisplayName(EParameterName.DUMMY.getDisplayName());
    param.setFieldType(EParameterFieldType.CHECK);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(5);
    param.setReadOnly(false);
    param.setRequired(false);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.HELP.getName());
    param.setValue(getTranslatedValue(PROP_HELP));
    param.setDisplayName(EParameterName.HELP.getDisplayName());
    param.setFieldType(EParameterFieldType.TEXT);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(6);
    param.setReadOnly(true);
    param.setRequired(false);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.UPDATE_COMPONENTS.getName());
    param.setValue(new Boolean(false));
    param.setDisplayName(EParameterName.UPDATE_COMPONENTS.getDisplayName());
    param.setFieldType(EParameterFieldType.CHECK);
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setNumRow(5);
    param.setReadOnly(true);
    param.setRequired(false);
    param.setShow(false);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.IREPORT_PATH.getName());
    param.setCategory(EComponentCategory.TECHNICAL);
    param.setFieldType(EParameterFieldType.DIRECTORY);
    param.setDisplayName(EParameterName.IREPORT_PATH.getDisplayName());
    param.setNumRow(99);
    param.setShow(false);
    param.setValue(CorePlugin.getDefault().getPluginPreferences().getString(ITalendCorePrefConstants.IREPORT_PATH));
    param.setReadOnly(true);
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.SUBJOB_COLOR.getName());
    param.setValue("String_Node_Str");
    param.setDisplayName(EParameterName.SUBJOB_COLOR.getDisplayName());
    param.setFieldType(EParameterFieldType.TEXT);
    param.setCategory(EComponentCategory.ADVANCED);
    param.setNumRow(99);
    param.setReadOnly(true);
    param.setShow(false);
    param.setDefaultValue(param.getValue());
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName(EParameterName.SUBJOB_TITLE_COLOR.getName());
    param.setValue("String_Node_Str");
    param.setDisplayName(EParameterName.SUBJOB_TITLE_COLOR.getDisplayName());
    param.setFieldType(EParameterFieldType.TEXT);
    param.setCategory(EComponentCategory.ADVANCED);
    param.setNumRow(99);
    param.setReadOnly(true);
    param.setShow(false);
    param.setDefaultValue(param.getValue());
    listParam.add(param);
    param = new ElementParameter(node);
    param.setName("String_Node_Str");
    param.setCategory(EComponentCategory.BASIC);
    param.setDisplayName(EParameterName.PROPERTY_TYPE.getDisplayName());
    param.setFieldType(EParameterFieldType.PROPERTY_TYPE);
    param.setRepositoryValue(getRepositoryType());
    param.setValue("String_Node_Str");
    param.setNumRow(99);
    String context = "String_Node_Str";
    ElementParameter newParam = new ElementParameter(node);
    newParam.setCategory(EComponentCategory.BASIC);
    newParam.setName(EParameterName.PROPERTY_TYPE.getName());
    newParam.setDisplayName(EParameterName.PROPERTY_TYPE.getDisplayName());
    newParam.setListItemsDisplayName(new String[] { TEXT_BUILTIN, TEXT_REPOSITORY });
    newParam.setListItemsDisplayCodeName(new String[] { BUILTIN, REPOSITORY });
    newParam.setListItemsValue(new String[] { BUILTIN, REPOSITORY });
    newParam.setValue(BUILTIN);
    newParam.setNumRow(param.getNumRow());
    newParam.setFieldType(EParameterFieldType.TECHNICAL);
    newParam.setShow(false);
    newParam.setShowIf(param.getName() + "String_Node_Str" + REPOSITORY + "String_Node_Str");
    newParam.setReadOnly(param.isReadOnly());
    newParam.setNotShowIf(param.getNotShowIf());
    newParam.setContext(context);
    newParam.setSerialized(true);
    newParam.setParentParameter(param);
    newParam = new ElementParameter(node);
    newParam.setCategory(EComponentCategory.BASIC);
    newParam.setName(EParameterName.REPOSITORY_PROPERTY_TYPE.getName());
    newParam.setDisplayName(EParameterName.REPOSITORY_PROPERTY_TYPE.getDisplayName());
    newParam.setListItemsDisplayName(new String[] {});
    newParam.setListItemsValue(new String[] {});
    newParam.setNumRow(param.getNumRow());
    newParam.setFieldType(EParameterFieldType.TECHNICAL);
    newParam.setValue("String_Node_Str");
    newParam.setShow(false);
    newParam.setRequired(true);
    newParam.setReadOnly(param.isReadOnly());
    newParam.setShowIf(param.getName() + "String_Node_Str" + REPOSITORY + "String_Node_Str");
    newParam.setNotShowIf(param.getNotShowIf());
    newParam.setContext(context);
    newParam.setSerialized(true);
    newParam.setParentParameter(param);
    listParam.add(param);
}

Output:
     param.setValue("String_Node_Str");
-    param.setNumRow(99);
+    param.setNumRow(2);
     String context = "String_Node_Str";


Input:
public void delegateAIEnded(AIRobot ai) {
    if (ai instanceof AIRobotSearchRandomBlock) {
        if (!ai.success()) {
            startDelegateAI(new AIRobotGotoSleep(robot));
        } else {
            releaseBlockFound();
            AIRobotSearchRandomBlock searchAI = (AIRobotSearchRandomBlock) ai;
            if (searchAI.takeResource()) {
                blockFound = searchAI.blockFound;
                searchAI.path.removeLast();
                startDelegateAI(new AIRobotGotoBlock(robot, searchAI.path));
            } else {
                startDelegateAI(new AIRobotGotoSleep(robot));
            }
        }
    } else if (ai instanceof AIRobotGotoBlock) {
        startDelegateAI(new AIRobotUseToolOnBlock(robot, blockFound));
    } else if (ai instanceof AIRobotUseToolOnBlock) {
        releaseBlockFound();
    } else if (ai instanceof AIRobotFetchAndEquipItemStack) {
        if (robot.getHeldItem() == null) {
            startDelegateAI(new AIRobotGotoSleep(robot));
        }
    }
}

Output:
                 blockFound = searchAI.blockFound;
-                searchAI.path.removeLast();
+                if (searchAI.path.size() > 1) {
+                    searchAI.path.removeLast();
+                }
                 startDelegateAI(new AIRobotGotoBlock(robot, searchAI.path));


Input:
public boolean isNextBreakpoint() {
    if (!openSocket) {
        return false;
    }
    InputStream in;
    try {
        askForStatus();
        in = s.getInputStream();
        LineNumberReader reader = new LineNumberReader(new InputStreamReader(in));
        return "String_Node_Str".equals(reader.readLine());
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

Output:
         askForStatus();
-        in = s.getInputStream();
-        LineNumberReader reader = new LineNumberReader(new InputStreamReader(in));
-        return "String_Node_Str".equals(reader.readLine());
+        ois = new NoHeaderObjectInputStream(s.getInputStream());
+        TraceBean traceBean = (TraceBean) ois.readObject();
+        return traceBean.equals(TraceStatusBean.NEXT_BREAKPOINT);
     } catch (IOException e) {


Input:
public void onClick(View v) {
    Intent intent = new Intent(MainActivity.this, DetailsActivity.class);
    intent.putExtra(EXTRA_CURRENT_ALBUM_POSITION, mAlbumPosition);
    startActivity(intent, ActivityOptions.makeSceneTransitionAnimation(MainActivity.this, mAlbumImage, mAlbumImage.getTransitionName()).toBundle());
}

Output:
     Intent intent = new Intent(MainActivity.this, DetailsActivity.class);
-    intent.putExtra(EXTRA_CURRENT_ALBUM_POSITION, mAlbumPosition);
+    intent.putExtra(EXTRA_STARTING_ALBUM_POSITION, mAlbumPosition);
     startActivity(intent, ActivityOptions.makeSceneTransitionAnimation(MainActivity.this, mAlbumImage, mAlbumImage.getTransitionName()).toBundle());


Input:
private void startRecovery() {
    recoveryAttemptCount++;
    BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
    if (isDebugEnabled())
        Log.d(TAG, "String_Node_Str");
    if (!adapter.isDiscovering()) {
        Log.w(TAG, "String_Node_Str");
        recoveryInProgress = true;
        discoveryStartConfirmed = false;
        if (isDebugEnabled())
            Log.d(TAG, "String_Node_Str");
        if (!adapter.startDiscovery()) {
            Log.w(TAG, "String_Node_Str");
        }
        if (isDebugEnabled())
            Log.d(TAG, "String_Node_Str" + adapter.isDiscovering());
        if (TIME_TO_LET_DISCOVERY_RUN_MILLIS > 0) {
            if (isDebugEnabled())
                Log.d(TAG, "String_Node_Str" + TIME_TO_LET_DISCOVERY_RUN_MILLIS + "String_Node_Str");
            discoveryCanceller.doInBackground();
        } else {
            Log.d(TAG, "String_Node_Str");
        }
    } else {
        Log.w(TAG, "String_Node_Str");
    }
}

Output:
         } else {
-            Log.d(TAG, "String_Node_Str");
+            if (isDebugEnabled())
+                Log.d(TAG, "String_Node_Str");
         }


Input:
public static void main(String[] args) throws Exception {
    String propsPath;
    if (args.length == 0) {
        propsPath = "String_Node_Str";
    } else {
        propsPath = args[0];
    }
    Timer.start("String_Node_Str");
    SphinxProperties.initContext("String_Node_Str", new URL(propsPath));
    LargeTrigramModel sm = new LargeTrigramModel("String_Node_Str");
    Timer.stop("String_Node_Str");
    Timer.dumpAll();
    LogMath logMath = LogMath.getLogMath("String_Node_Str");
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String input;
    System.out.println("String_Node_Str" + sm.getMaxDepth());
    System.out.print("String_Node_Str");
    while ((input = reader.readLine()) != null) {
        StringTokenizer st = new StringTokenizer(input);
        List list = new ArrayList();
        while (st.hasMoreTokens()) {
            String tok = (String) st.nextToken();
            list.add(tok);
        }
        WordSequence wordSequence = new WordSequence(list);
        float logProbability = sm.getProbability(wordSequence);
        System.out.println("String_Node_Str" + wordSequence + "String_Node_Str" + logProbability + "String_Node_Str" + LogMath.logToLog(logProbability, logMath.getLogBase(), 10.0f) + "String_Node_Str");
        long usedMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("String_Node_Str" + usedMemory + "String_Node_Str");
        System.out.print("String_Node_Str");
    }
    Timer timer = Timer.getTimer("String_Node_Str", "String_Node_Str");
    List list1 = new ArrayList();
    WordSequence ws1 = new WordSequence("String_Node_Str", "String_Node_Str", "String_Node_Str");
    WordSequence ws2 = new WordSequence("String_Node_Str", "String_Node_Str", "String_Node_Str");
    for (int i = 0; i < 1000000; i++) {
        timer.start();
        sm.getProbability(ws1);
        timer.stop();
        timer.start();
        sm.getProbability(ws2);
        timer.stop();
    }
    Timer.dumpAll("String_Node_Str");
}

Output:
     if (args.length == 0) {
-        propsPath = "String_Node_Str";
-    } else {
-        propsPath = args[0];
+        System.out.println("String_Node_Str" + "String_Node_Str");
+    }
+    propsPath = args[0];
+    if (args.length == 2) {
+        testFile = args[1];
     }


Input:
private void checkCrash(ArrayList<Event> currentRoundEvents) {
    if (userControl.compareTo(FailureLvl.CRASH) < 0) {
        Integer[] addrCopy = nodes.keySet().toArray(new Integer[0]);
        for (Integer i : addrCopy) {
            double rand = Utility.getRNG().nextDouble();
            if (rand < failureRate) {
                currentRoundEvents.add(Event.getFailure(i));
            }
        }
        addrCopy = crashedNodes.toArray(new Integer[0]);
        for (Integer i : addrCopy) {
            double rand = Utility.getRNG().nextDouble();
            if (rand < recoveryRate) {
                currentRoundEvents.add(Event.getStart(i, 0));
            }
        }
    } else {
        try {
            printLiveDead();
            String input;
            if (!nodes.isEmpty()) {
                System.out.println("String_Node_Str");
                input = m_prompt ? Replay.getLine().trim() : "String_Node_Str";
                if (!input.equals("String_Node_Str")) {
                    String[] crashList = input.split("String_Node_Str");
                    for (String s : crashList) {
                        currentRoundEvents.add(Event.getFailure(Integer.parseInt(s)));
                    }
                }
            }
            if (!crashedNodes.isEmpty()) {
                System.out.println("String_Node_Str");
                input = m_prompt ? Replay.getLine().trim() : "String_Node_Str";
                if (!input.equals("String_Node_Str")) {
                    String[] restartList = input.split("String_Node_Str");
                    for (String s : restartList) {
                        currentRoundEvents.add(Event.getStart(Integer.parseInt(s), 0));
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:
             if (!nodes.isEmpty()) {
-                System.out.println("String_Node_Str");
-                input = m_prompt ? Replay.getLine().trim() : "String_Node_Str";
+                input = "String_Node_Str";
+                if (m_prompt) {
+                    System.out.println("String_Node_Str");
+                    input = Replay.getLine().trim();
+                }
                 if (!input.equals("String_Node_Str")) {


Input:
private void loadLevel(final JdbcSchema.Table.Column.Usage usage) {
    String name = usage.getSymbolicName();
    MondrianDef.Expression expression = new MondrianDef.Column(getName(), usage.levelColumnName);
    int bitPosition = usage.rColumn.getBitPosition();
    Level level = new Level(name, expression, bitPosition, usage.rColumn, usage.collapsed);
    addLevel(level);
    if (!usage.collapsed) {
        RolapLevel parentLevel = (RolapLevel) usage.level.getParentLevel();
        while (!parentLevel.isAll()) {
            final BitKey bk = AggStar.this.star.getBitKey(new String[] { parentLevel.getKeyExp().getTableAlias() }, new String[] { ((MondrianDef.Column) parentLevel.getKeyExp()).getColumnName() });
            final int bitPos = bk.nextSetBit(0);
            if (bitPos == -1) {
                throw new MondrianException("String_Node_Str");
            }
            DimTable columnTable = convertTable(AggStar.this.star.getColumn(bitPosition).getTable(), null);
            while (columnTable.getChildTables().size() > 0) {
                columnTable = columnTable.getChildTables().get(0);
            }
            final DimTable finalColumnTable = columnTable;
            levelColumnsToJoin.put(bitPos, new Column(((MondrianDef.Column) parentLevel.getKeyExp()).getColumnName(), parentLevel.getKeyExp(), AggStar.this.star.getColumn(bitPos).getDatatype(), bitPos) {
                public Table getTable() {
                    return finalColumnTable;
                }
            });
            parentLevel = (RolapLevel) parentLevel.getParentLevel();
        }
    }
}

Output:
             }
-            DimTable columnTable = convertTable(AggStar.this.star.getColumn(bitPosition).getTable(), null);
+            DimTable columnTable = convertTable(AggStar.this.star.getColumn(bitPosition).getTable(), usage.levelColumnName);
             while (columnTable.getChildTables().size() > 0) {


Input:
public void execute() {
    LOG.log(Level.INFO, "String_Node_Str");
    for (int i = 0; i < 100000; i++) {
        IntData data = generateData();
        while (getDfop().send(0, data)) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        sendCount++;
        Thread.yield();
    }
    status = Status.MAP_FINISHED;
}

Output:
         IntData data = generateData();
-        while (getDfop().send(0, data)) {
+        while (!getDfop().send(0, data)) {
             try {


Input:
public static synchronized Pair<ManagedObjectReference, String> preparePublicNetwork(String vSwitchName, HostMO hostMo, String vlanId, Integer networkRateMbps, Integer networkRateMulticastMbps, long timeOutMs, boolean syncPeerHosts) throws Exception {
    HostVirtualSwitch vSwitch = hostMo.getHostVirtualSwitchByName(vSwitchName);
    if (vSwitch == null) {
        String msg = "String_Node_Str";
        s_logger.error(msg);
        throw new Exception(msg);
    }
    boolean createGCTag = false;
    String networkName;
    Integer vid = null;
    if (vlanId != null && !UNTAGGED_VLAN_NAME.equalsIgnoreCase(vlanId)) {
        createGCTag = true;
        vid = Integer.parseInt(vlanId);
    }
    networkName = composeCloudNetworkName("String_Node_Str", vlanId, networkRateMbps, vSwitchName);
    HostNetworkTrafficShapingPolicy shapingPolicy = null;
    if (networkRateMbps != null && networkRateMbps.intValue() > 0) {
        shapingPolicy = new HostNetworkTrafficShapingPolicy();
        shapingPolicy.setEnabled(true);
        shapingPolicy.setAverageBandwidth((long) networkRateMbps.intValue() * 1024L * 1024L);
        shapingPolicy.setPeakBandwidth((long) (shapingPolicy.getAverageBandwidth() * 1.5));
        shapingPolicy.setBurstSize(5 * shapingPolicy.getAverageBandwidth() / 8);
    }
    if (!hostMo.hasPortGroup(vSwitch, networkName)) {
        hostMo.createPortGroup(vSwitch, networkName, vid, shapingPolicy);
    } else {
        hostMo.updatePortGroup(vSwitch, networkName, vid, shapingPolicy);
    }
    ManagedObjectReference morNetwork = waitForNetworkReady(hostMo, networkName, timeOutMs);
    if (morNetwork == null) {
        String msg = "String_Node_Str" + vSwitchName;
        s_logger.error(msg);
        throw new Exception(msg);
    }
    if (createGCTag) {
        NetworkMO networkMo = new NetworkMO(hostMo.getContext(), morNetwork);
        networkMo.setCustomFieldValue(CustomFieldConstants.CLOUD_GC, "String_Node_Str");
    }
    if (syncPeerHosts) {
        ManagedObjectReference morParent = hostMo.getParentMor();
        if (morParent != null && morParent.getType().equals("String_Node_Str")) {
            GlobalLock lock = GlobalLock.getInternLock("String_Node_Str" + morParent.get_value());
            try {
                if (lock.lock(DEFAULT_LOCK_TIMEOUT_SECONDS)) {
                    try {
                        ManagedObjectReference[] hosts = (ManagedObjectReference[]) hostMo.getContext().getServiceUtil().getDynamicProperty(morParent, "String_Node_Str");
                        if (hosts != null) {
                            for (ManagedObjectReference otherHost : hosts) {
                                if (!otherHost.get_value().equals(hostMo.getMor().get_value())) {
                                    HostMO otherHostMo = new HostMO(hostMo.getContext(), otherHost);
                                    try {
                                        if (s_logger.isDebugEnabled())
                                            s_logger.debug("String_Node_Str" + vlanId + "String_Node_Str" + otherHostMo.getHostName());
                                        preparePublicNetwork(vSwitchName, otherHostMo, vlanId, networkRateMbps, networkRateMulticastMbps, timeOutMs, false);
                                    } catch (Exception e) {
                                        s_logger.warn("String_Node_Str" + vlanId + "String_Node_Str" + otherHostMo.getHostName());
                                    }
                                }
                            }
                        }
                    } finally {
                        lock.unlock();
                    }
                } else {
                    s_logger.warn("String_Node_Str" + vlanId);
                }
            } finally {
                lock.releaseRef();
            }
        }
    }
    s_logger.info("String_Node_Str" + networkName + "String_Node_Str" + vSwitchName);
    return new Pair<ManagedObjectReference, String>(morNetwork, networkName);
}

Output:
     } else {
-        hostMo.updatePortGroup(vSwitch, networkName, vid, shapingPolicy);
+        HostPortGroupSpec spec = hostMo.getPortGroupSpec(networkName);
+        if (!isSpecMatch(spec, vid, shapingPolicy)) {
+            hostMo.updatePortGroup(vSwitch, networkName, vid, shapingPolicy);
+            bWaitPortGroupReady = true;
+        }
     }


Input:
public void testGetHadoopDistributionsDisplay_withCustom__Sorted() {
    String[] hadoopDistributionsDisplay = HadoopDistributionsHelper.HADOOP.getDistributionsDisplay(true);
    Assert.assertArrayEquals(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }, hadoopDistributionsDisplay);
}

Output:
     String[] hadoopDistributionsDisplay = HadoopDistributionsHelper.HADOOP.getDistributionsDisplay(true);
-    Assert.assertArrayEquals(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }, hadoopDistributionsDisplay);
+    Assert.assertArrayEquals(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }, hadoopDistributionsDisplay);
 }


Input:
public String toString() {
    final StringBuilder sb = new StringBuilder("String_Node_Str");
    sb.append("String_Node_Str").append(deadlockedThreadIdSet);
    sb.append('}');
    return sb.toString();
}

Output:
     final StringBuilder sb = new StringBuilder("String_Node_Str");
-    sb.append("String_Node_Str").append(deadlockedThreadIdSet);
+    sb.append("String_Node_Str").append(deadlockedThreadIdMap.keySet());
     sb.append('}');


Input:
public void test_regression_155943() throws DesignFileException, SemanticException, IOException {
    String report = getTempFolder() + "String_Node_Str" + INPUT_FOLDER + "String_Node_Str" + INPUT;
    String libA = getTempFolder() + "String_Node_Str" + INPUT_FOLDER + "String_Node_Str" + LIBRARY;
    sessionHandle = new DesignEngine(new DesignConfig()).newSessionHandle(ULocale.ENGLISH);
    designHandle = sessionHandle.openDesign(report);
    ExtendedItemHandle chart = (ExtendedItemHandle) designHandle.findElement("String_Node_Str");
    assertNotNull(chart);
    assertEquals("String_Node_Str", chart.getName());
    List list = new ArrayList();
    list.add(chart);
    SimpleGroupElementHandle group = new SimpleGroupElementHandle(designHandle, list);
    assertFalse(group.hasLocalPropertiesForExtendedElements());
    chart.setProperty(ReportItemHandle.WIDTH_PROP, "String_Node_Str");
    assertEquals("String_Node_Str", chart.getProperty(ReportItemHandle.WIDTH_PROP).toString());
    assertTrue(group.hasLocalPropertiesForExtendedElements());
    group.clearLocalProperties();
    assertFalse(group.hasLocalPropertiesForExtendedElements());
}

Output:
     String libA = getTempFolder() + "String_Node_Str" + INPUT_FOLDER + "String_Node_Str" + LIBRARY;
-    sessionHandle = new DesignEngine(new DesignConfig()).newSessionHandle(ULocale.ENGLISH);
-    designHandle = sessionHandle.openDesign(report);
+    openDesign(INPUT);
     ExtendedItemHandle chart = (ExtendedItemHandle) designHandle.findElement("String_Node_Str");


Input:
private void buildWhereClauseDistinctConstraints(StringBuffer queryBuf, List params) {
    if (containerIDField != null && containerID != -1 && containerTable != null) {
        buildWhereClauseOpInsert(queryBuf);
        queryBuf.append("String_Node_Str");
        queryBuf.append(containerTable);
        queryBuf.append("String_Node_Str");
        queryBuf.append(containerIDField);
        queryBuf.append("String_Node_Str" + table + "String_Node_Str");
        params.add(new Integer(containerID));
    }
}

Output:
         queryBuf.append("String_Node_Str");
-        queryBuf.append(containerTable);
+        buildFocusedSelectTables(queryBuf);
         queryBuf.append("String_Node_Str");


Input:
public void setItemInHand(int UID, String material) {
    Material mat = StringUtils.parseMaterial(material);
    if (mat == null)
        mat = StringUtils.parseMaterial(PropertyPool.itemlookups.getString(material));
    HumanNPC NPC = super.getNPC(UID);
    ArrayList<Integer> items = PropertyPool.getItemsFromFile(UID);
    int olditem = items.get(0);
    items.set(0, mat.getId());
    NPCDataManager.addItems(NPC, items);
    if ((olditem != 0 && items.get(0) == 0)) {
        super.removeNPCForRespawn(NPC.getUID());
        super.registerBasicNPC(NPC.getName(), NPC.getType(), NPC.getUID());
    }
}

Output:
     Material mat = StringUtils.parseMaterial(material);
-    if (mat == null)
+    if (mat == null && !PropertyPool.itemlookups.getString(material).isEmpty())
         mat = StringUtils.parseMaterial(PropertyPool.itemlookups.getString(material));


Input:
public void subscribe(ContactGroup parentGroup, String contactIdentifier) throws IllegalArgumentException, IllegalStateException, OperationFailedException {
    logger.debug("String_Node_Str" + contactIdentifier);
    ContactSipImpl contact = (ContactSipImpl) resolveContactID(contactIdentifier);
    if (contact != null && contact.isPersistent()) {
        throw new OperationFailedException("String_Node_Str" + contactIdentifier + "String_Node_Str", OperationFailedException.SUBSCRIPTION_ALREADY_EXISTS);
    } else if (!contact.isPersistent()) {
        ContactGroupSipImpl oldParentGroup = (ContactGroupSipImpl) contact.getParentContactGroup();
        oldParentGroup.removeContact(contact);
        fireSubscriptionEvent(contact, oldParentGroup, SubscriptionEvent.SUBSCRIPTION_REMOVED);
    }
    Address contactAddress;
    try {
        contactAddress = parentProvider.parseAddressString(contactIdentifier);
    } catch (ParseException exc) {
        throw new IllegalArgumentException(contactIdentifier + "String_Node_Str", exc);
    }
    contact = new ContactSipImpl(contactAddress, this.parentProvider);
    ((ContactGroupSipImpl) parentGroup).addContact(contact);
    fireSubscriptionEvent(contact, parentGroup, SubscriptionEvent.SUBSCRIPTION_CREATED);
    if (this.presenceEnabled == false)
        return;
    assertConnected();
    Request subscription;
    try {
        subscription = createSubscription(contact, this.subscriptionDuration);
    } catch (OperationFailedException ex) {
        logger.error("String_Node_Str", ex);
        throw new OperationFailedException("String_Node_Str", OperationFailedException.INTERNAL_ERROR);
    }
    ClientTransaction subscribeTransaction;
    SipProvider jainSipProvider = this.parentProvider.getDefaultJainSipProvider();
    try {
        subscribeTransaction = jainSipProvider.getNewClientTransaction(subscription);
    } catch (TransactionUnavailableException ex) {
        logger.error("String_Node_Str" + "String_Node_Str", ex);
        throw new OperationFailedException("String_Node_Str", OperationFailedException.NETWORK_FAILURE);
    }
    CallIdHeader idheader = (CallIdHeader) subscription.getHeader(CallIdHeader.NAME);
    this.subscribedContacts.put(idheader.getCallId(), contact);
    try {
        subscribeTransaction.sendRequest();
    } catch (SipException ex) {
        logger.error("String_Node_Str", ex);
        this.subscribedContacts.remove(idheader.getCallId());
        throw new OperationFailedException("String_Node_Str", OperationFailedException.NETWORK_FAILURE);
    }
}

Output:
     ContactSipImpl contact = (ContactSipImpl) resolveContactID(contactIdentifier);
-    if (contact != null && contact.isPersistent()) {
-        throw new OperationFailedException("String_Node_Str" + contactIdentifier + "String_Node_Str", OperationFailedException.SUBSCRIPTION_ALREADY_EXISTS);
-    } else if (!contact.isPersistent()) {
-        ContactGroupSipImpl oldParentGroup = (ContactGroupSipImpl) contact.getParentContactGroup();
-        oldParentGroup.removeContact(contact);
-        fireSubscriptionEvent(contact, oldParentGroup, SubscriptionEvent.SUBSCRIPTION_REMOVED);
+    if (contact != null) {
+        if (contact.isPersistent()) {
+            throw new OperationFailedException("String_Node_Str" + contactIdentifier + "String_Node_Str", OperationFailedException.SUBSCRIPTION_ALREADY_EXISTS);
+        } else {
+            ContactGroupSipImpl oldParentGroup = (ContactGroupSipImpl) contact.getParentContactGroup();
+            oldParentGroup.removeContact(contact);
+            fireSubscriptionEvent(contact, oldParentGroup, SubscriptionEvent.SUBSCRIPTION_REMOVED);
+        }
     }


Input:
public void testUnloadResourcesProperty() throws PersistenceException, CoreException, LoginException {
    repositoryFactory.logOnProject(sampleProject);
    Property property = PropertiesFactory.eINSTANCE.createProperty();
    property.setAuthor(sampleProject.getAuthor());
    property.setVersion(VersionUtils.DEFAULT_VERSION);
    property.setStatusCode("String_Node_Str");
    property.setLabel("String_Node_Str");
    final String nextId = repositoryFactory.getNextId();
    property.setId(nextId);
    ProcessItem processItem = PropertiesFactory.eINSTANCE.createProcessItem();
    processItem.setProperty(property);
    ProcessType process = TalendFileFactory.eINSTANCE.createProcessType();
    processItem.setProcess(process);
    Property property2 = PropertiesFactory.eINSTANCE.createProperty();
    property2.setAuthor(sampleProject.getAuthor());
    property2.setVersion(VersionUtils.DEFAULT_VERSION);
    property2.setStatusCode("String_Node_Str");
    property2.setLabel("String_Node_Str");
    final String nextId2 = repositoryFactory.getNextId();
    property2.setId(nextId2);
    ProcessItem processItem2 = PropertiesFactory.eINSTANCE.createProcessItem();
    processItem2.setProperty(property2);
    ProcessType process2 = TalendFileFactory.eINSTANCE.createProcessType();
    processItem2.setProcess(process2);
    repositoryFactory.create(sampleProject, processItem, new Path("String_Node_Str"), false);
    repositoryFactory.create(sampleProject, processItem2, new Path("String_Node_Str"), false);
    assertNotNull(processItem.eResource());
    assertNotNull(processItem2.eResource());
    repositoryFactory.unloadResources(property2);
    assertNotNull(processItem.eResource());
    assertNull(processItem2.eResource());
    property = repositoryFactory.getUptodateProperty(sampleProject, property);
    repositoryFactory.deleteObjectPhysical(sampleProject, new RepositoryObject(property));
    property2 = repositoryFactory.getUptodateProperty(sampleProject, property2);
    repositoryFactory.deleteObjectPhysical(sampleProject, new RepositoryObject(property2));
}

Output:
     property = repositoryFactory.getUptodateProperty(sampleProject, property);
-    repositoryFactory.deleteObjectPhysical(sampleProject, new RepositoryObject(property));
+    repositoryFactory.deleteObjectPhysical(sampleProject, new RepositoryObject(property), false);
     property2 = repositoryFactory.getUptodateProperty(sampleProject, property2);


Input:
protected BigDecimal convertObjectToNumber(Object sourceObject) throws ConversionException {
    if (sourceObject instanceof String && ((String) sourceObject).startsWith(PLUS)) {
        return super.convertObjectToNumber(((String) sourceObject).substring(1));
    }
    return super.convertObjectToNumber(sourceObject);
}

Output:
 protected BigDecimal convertObjectToNumber(Object sourceObject) throws ConversionException {
-    if (sourceObject instanceof String && ((String) sourceObject).startsWith(PLUS)) {
+    if (sourceObject instanceof String && ((String) sourceObject).length() > 0 && ((String) sourceObject).charAt(0) == PLUS) {
         return super.convertObjectToNumber(((String) sourceObject).substring(1));


Input:
public OverlayVertexWrapper<V, E> refTo(final OverlayVertexWrapper<V, E> obj) {
    wv = wrapper.idmap.getVertex(obj.getInternalPoolIndex(), wv);
    return this;
}

Output:
 public OverlayVertexWrapper<V, E> refTo(final OverlayVertexWrapper<V, E> obj) {
-    wv = wrapper.idmap.getVertex(obj.getInternalPoolIndex(), wv);
+    wv = wrapper.idmap.getVertex(obj.getInternalPoolIndex(), ref);
     return this;


Input:
public static void main(String[] args) {
    if (args.length < 2) {
        System.err.println("String_Node_Str");
        System.exit(1);
    }
    String botName = args[0];
    String devkey = args[1];
    String host = (args.length >= 2) ? args[2] : "String_Node_Str";
    Bot bot = new SimpleBot();
    GameHost gameHost = new RemoteGameHost(botName, devkey, host);
    BotRunner runner = new BotRunner(gameHost, bot);
    runner.play(1);
}

Output:
     String devkey = args[1];
-    String host = (args.length >= 2) ? args[2] : "String_Node_Str";
+    String host = (args.length > 2) ? args[2] : "String_Node_Str";
     Bot bot = new SimpleBot();


Input:
public StringBuffer generateCode(ModelType modelType, String inputTemporalFormula, FormulaType formulaType, int variableSpanSize, int FSMBufferSize) throws IllegalActionException, NameDuplicationException, CloneNotSupportedException {
    StringBuffer systemDescription = new StringBuffer("String_Node_Str");
    switch(modelType) {
        case Kripke:
            if (_model instanceof CompositeActor)
                systemDescription.append(SMVUtility.generateSMVDescription((CompositeActor) _model.clone(), inputTemporalFormula, formulaType.toString(), String.valueOf(variableSpanSize)));
            else
                systemDescription.append(((FmvAutomaton) _model.clone()).convertToSMVFormat(inputTemporalFormula, formulaType, variableSpanSize));
            break;
        case CTA:
            systemDescription.append(REDUtility.generateREDDescription((CompositeActor) _model.clone(), inputTemporalFormula, formulaType, variableSpanSize, FSMBufferSize));
            break;
        case Maude:
            if (_model instanceof CompositeActor)
                if (template.getExpression().trim().equals("String_Node_Str")) {
                    systemDescription.append(RTMaudeUtility.generateRTMDescription((CompositeActor) _model, inputTemporalFormula, true));
                } else {
                    systemDescription.append(RTMaudeUtility.generateRTMDescription(template.openForReading(), (CompositeActor) _model, inputTemporalFormula));
                }
            break;
    }
    return systemDescription;
}

Output:
         case CTA:
-            systemDescription.append(REDUtility.generateREDDescription((CompositeActor) _model.clone(), inputTemporalFormula, formulaType, variableSpanSize, FSMBufferSize));
+            systemDescription.append(REDUtility.generateREDDescription((CompositeActor) _model.clone(), inputTemporalFormula, formulaType, variableSpanSize, delayActorBufferSize));
             break;


Input:
public void initGui(int xPos, int yPos, int width, int height) {
    super.initGui(xPos, yPos, width, height);
    textureTypeList = new GuiDropDownList(0, width / 2 - 110, 25, 50, "String_Node_Str", this);
    textureTypeList.addListItem(GuiHelper.getLocalizedControlName(tileEntity.getInventoryName(), "String_Node_Str"), TextureType.USER.toString(), true);
    textureTypeList.addListItem(GuiHelper.getLocalizedControlName(tileEntity.getInventoryName(), "String_Node_Str"), TextureType.URL.toString(), true);
    textureTypeList.setListSelectedIndex(tileEntity.getTextureType().ordinal());
    nameTextbox = new GuiTextField(fontRenderer, width / 2 - 110 + 55, 25, 165, 14);
    nameTextbox.setMaxStringLength(200);
    if (tileEntity.getTextureType() == TextureType.USER) {
        if (tileEntity.getGameProfile() != null) {
            nameTextbox.setText(tileEntity.getGameProfile().getName());
        }
    } else {
        if (tileEntity.getImageUrl() != null) {
            nameTextbox.setText(tileEntity.getImageUrl());
        }
    }
    setNameButton = new GuiButtonExt(0, width / 2 + 60, 45, 50, 14, GuiHelper.getLocalizedControlName(tileEntity.getInventoryName(), "String_Node_Str"));
    buttonList.add(textureTypeList);
    buttonList.add(setNameButton);
}

Output:
     nameTextbox = new GuiTextField(fontRenderer, width / 2 - 110 + 55, 25, 165, 14);
-    nameTextbox.setMaxStringLength(200);
+    nameTextbox.setMaxStringLength(300);
     if (tileEntity.getTextureType() == TextureType.USER) {


Input:
public void run() throws Exception {
    final MutableObjectIterator<PactRecord> input = this.inputs[0];
    final MapStub stub = this.stub;
    final Collector output = this.output;
    final PactRecord record = new PactRecord();
    int count = 0;
    long consumedPactRecordsInBytes = 0L;
    final Environment env = getEnvironment();
    final OutputCollector oc = (OutputCollector) output;
    if (this.stub.getClass().isAnnotationPresent(ForceCheckpoint.class)) {
        env.isForced(this.stub.getClass().getAnnotation(ForceCheckpoint.class).checkpoint());
    }
    while (this.running && input.next(record)) {
        consumedPactRecordsInBytes = +record.getBinaryLength();
        stub.map(record, output);
        if (++count == 10) {
            env.reportPACTDataStatistics(consumedPactRecordsInBytes, oc.getCollectedPactRecordsInBytes());
            consumedPactRecordsInBytes = 0L;
            count = 0;
        }
    }
}

Output:
     while (this.running && input.next(record)) {
-        consumedPactRecordsInBytes = +record.getBinaryLength();
+        consumedPactRecordsInBytes += record.getBinaryLength();
         stub.map(record, output);


Input:
public void deriveSigningKeyTest() {
    AwsConfig awsConfig = new AwsConfig();
    awsConfig.setRegion(TEST_REGION);
    awsConfig.setHostHeader(TEST_HOST);
    awsConfig.setAccessKey(TEST_ACCESS_KEY);
    awsConfig.setSecretKey(TEST_SECRET_KEY);
    DescribeInstances di = new DescribeInstances(awsConfig);
    try {
        Field field = null;
        Map<String, String> attributes = null;
        field = di.getClass().getDeclaredField("String_Node_Str");
        field.setAccessible(true);
        attributes = (Map<String, String>) field.get(di);
        attributes.put("String_Node_Str", TEST_REQUEST_DATE);
        field.set(di, attributes);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    EC2RequestSigner rs = new EC2RequestSigner(awsConfig, TEST_REQUEST_DATE);
    byte[] derivedKey = null;
    try {
        Field field = null;
        field = rs.getClass().getDeclaredField("String_Node_Str");
        field.setAccessible(true);
        field.set(rs, "String_Node_Str");
        Method method = null;
        method = rs.getClass().getDeclaredMethod("String_Node_Str", null);
        method.setAccessible(true);
        derivedKey = (byte[]) method.invoke(rs);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    assertEquals(TEST_DERIVED_EXPECTED, bytesToHex(derivedKey));
}

Output:
     awsConfig.setSecretKey(TEST_SECRET_KEY);
-    DescribeInstances di = new DescribeInstances(awsConfig);
+    DescribeInstances di = new DescribeInstances(awsConfig, TEST_HOST);
     try {


Input:
protected APIResponse.CODE doInBackground(String... params) {
    eventKey = params[0];
    teams = new ArrayList<>();
    try {
        APIResponse<ArrayList<JsonArray>> response = DataManager.Events.getEventRankings(activity, eventKey, requestParams);
        ArrayList<JsonArray> rankList = response.getData();
        if (isCancelled()) {
            return APIResponse.CODE.NODATA;
        }
        if (!rankList.isEmpty()) {
            JsonArray headerRow = rankList.remove(0);
            for (JsonArray row : rankList) {
                String teamKey = "String_Node_Str" + row.get(1).getAsString();
                String rankingString = "String_Node_Str";
                EventHelper.CaseInsensitiveMap<String> rankingElements = new EventHelper.CaseInsensitiveMap<>();
                for (int i = 2; i < row.size(); i++) {
                    rankingElements.put(headerRow.get(i).getAsString(), row.get(i).getAsString());
                }
                String record = null;
                Iterator it = rankingElements.entrySet().iterator();
                while (it.hasNext()) {
                    Map.Entry<String, Object> entry = (Map.Entry) it.next();
                    if (entry.getKey().toLowerCase().contains("String_Node_Str".toLowerCase())) {
                        record = "String_Node_Str" + rankingElements.get(entry.getKey()) + "String_Node_Str";
                        it.remove();
                        break;
                    }
                }
                if (record == null) {
                    Set<String> keys = rankingElements.keySet();
                    if (keys.contains("String_Node_Str") && keys.contains("String_Node_Str") && keys.contains("String_Node_Str")) {
                        record = "String_Node_Str" + rankingElements.get("String_Node_Str") + "String_Node_Str" + rankingElements.get("String_Node_Str") + "String_Node_Str" + rankingElements.get("String_Node_Str") + "String_Node_Str";
                        rankingElements.remove("String_Node_Str");
                        rankingElements.remove("String_Node_Str");
                        rankingElements.remove("String_Node_Str");
                    }
                }
                if (record == null) {
                    record = "String_Node_Str";
                }
                rankingString = EventHelper.createRankingBreakdown(rankingElements);
                Team team = DataManager.Teams.getTeamFromDB(activity, teamKey);
                String nickname;
                if (team != null) {
                    nickname = team.getNickname();
                } else {
                    nickname = "String_Node_Str" + teamKey.substring(3);
                }
                teams.add(new RankingListElement(teamKey, row.get(1).getAsInt(), nickname, row.get(0).getAsInt(), record, rankingString));
            }
            adapter = new ListViewAdapter(activity, teams);
            return response.getCode();
        } else {
            return APIResponse.CODE.NODATA;
        }
    } catch (DataManager.NoDataException e) {
        Log.w(Constants.LOG_TAG, "String_Node_Str");
        return APIResponse.CODE.NODATA;
    }
}

Output:
                 }
-                String record = null;
-                Iterator it = rankingElements.entrySet().iterator();
-                while (it.hasNext()) {
-                    Map.Entry<String, Object> entry = (Map.Entry) it.next();
-                    if (entry.getKey().toLowerCase().contains("String_Node_Str".toLowerCase())) {
-                        record = "String_Node_Str" + rankingElements.get(entry.getKey()) + "String_Node_Str";
-                        it.remove();
-                        break;
-                    }
-                }
+                String record = EventHelper.extractRankingString(rankingElements);
                 if (record == null) {


Input:
public void showDepartureList(MVVObject dep) {
    try {
        mvvList = dep.getResultList();
        int widgetID = intent.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1);
        appWidgetManager.notifyAppWidgetViewDataChanged(widgetID, R.id.mvv_widget_item);
    } catch (Exception e) {
        Utils.log(e);
        Utils.showToast(applicationContext, "String_Node_Str");
    }
}

Output:
         Utils.log(e);
-        Utils.showToast(applicationContext, "String_Node_Str");
+        Utils.showToast(applicationContext, applicationContext.getString(R.string.something_is_wrong));
     }


Input:
public void updateFireAtTimes(RealTimeClock realTimeClock, Time newClockDrift) throws IllegalActionException {
    if (realTimeClock._clockDrift != realTimeClock._previousClockDrift) {
        Time newOracleTime = _getOraclePhysicalTag().timestamp;
        realTimeClock._lastPlatformTime = ((newOracleTime.subtract(realTimeClock._lastOracleTime)).multiply(realTimeClock._clockDrift)).add(realTimeClock._lastPlatformTime);
        realTimeClock._lastOracleTime = newOracleTime;
        realTimeClock._previousClockDrift = realTimeClock._clockDrift;
        realTimeClock._clockDrift = newClockDrift;
        if (realTimeClock == _executionTimeClock) {
            _futureExecutionFireAtTimes = _updateFireAtTimes(_futureExecutionFireAtTimes, _ignoredExecutionFireAtTimes, realTimeClock);
        } else if (realTimeClock == _platformTimeClock) {
            _futurePlatformFireAtTimes = _updateFireAtTimes(_futurePlatformFireAtTimes, _ignoredPlatformFireAtTimes, realTimeClock);
            _timedInterruptWakeUpTimes = _updateFireAtTimes(_timedInterruptWakeUpTimes, null, realTimeClock);
        } else {
            throw new InternalErrorException(this, null, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
        }
    }
}

Output:
 public void updateFireAtTimes(RealTimeClock realTimeClock, Time newClockDrift) throws IllegalActionException {
-    if (realTimeClock._clockDrift != realTimeClock._previousClockDrift) {
+    if (realTimeClock._clockDrift.compareTo(newClockDrift) != 0) {
         Time newOracleTime = _getOraclePhysicalTag().timestamp;


Input:
public static String getBoundary(final String contentType, final int line) throws BatchDeserializerException {
    final ContentType type = getContentType(contentType, ContentType.MULTIPART_MIXED, line);
    final Map<String, String> parameters = type.getParameters();
    for (final Map.Entry<String, String> entries : parameters.entrySet()) {
        if (BOUNDARY.equalsIgnoreCase(entries.getKey())) {
            final String boundary = entries.getValue().trim();
            if (boundary.matches(PATTERN_BOUNDARY)) {
                return trimQuotes(boundary);
            } else {
                throw new BatchDeserializerException("String_Node_Str", BatchDeserializerException.MessageKeys.INVALID_BOUNDARY, Integer.toString(line));
            }
        }
    }
    throw new BatchDeserializerException("String_Node_Str", BatchDeserializerException.MessageKeys.MISSING_BOUNDARY_DELIMITER, Integer.toString(line));
}

Output:
 public static String getBoundary(final String contentType, final int line) throws BatchDeserializerException {
-    final ContentType type = getContentType(contentType, ContentType.MULTIPART_MIXED, line);
+    final ContentType type = parseContentType(contentType, ContentType.MULTIPART_MIXED, line);
     final Map<String, String> parameters = type.getParameters();


Input:
public List<IngameTrade> getIngameTrades() {
    List<IngameTrade> trades = new ArrayList<IngameTrade>();
    int tableOffset = romEntry.getValue("String_Node_Str");
    int tableSize = romEntry.getValue("String_Node_Str");
    int nicknameLength = romEntry.getValue("String_Node_Str");
    int otLength = romEntry.getValue("String_Node_Str");
    int[] unused = romEntry.arrayEntries.get("String_Node_Str");
    int unusedOffset = 0;
    int entryLength = nicknameLength + otLength + 10;
    for (int entry = 0; entry < tableSize; entry++) {
        if (unusedOffset < unused.length && unused[unusedOffset] == entry) {
            unusedOffset++;
            continue;
        }
        IngameTrade trade = new IngameTrade();
        int entryOffset = tableOffset + entry * entryLength;
        trade.requestedPokemon = pokes[rom[entryOffset + 1] & 0xFF];
        trade.givenPokemon = pokes[rom[entryOffset + 2] & 0xFF];
        trade.nickname = readString(entryOffset + 3, nicknameLength);
        int atkdef = rom[entryOffset + 3 + nicknameLength] & 0xFF;
        int spdspc = rom[entryOffset + 4 + nicknameLength] & 0xFF;
        trade.ivs = new int[] { (atkdef >> 4) & 0xF, atkdef & 0xF, (spdspc >> 4) & 0xF, spdspc & 0xF };
        trade.item = rom[entryOffset + 5 + nicknameLength] & 0xFF;
        trade.otId = readWord(entryOffset + 6 + nicknameLength);
        trade.otName = readString(entryOffset + 8 + nicknameLength, otLength);
        trades.add(trade);
    }
    return trades;
}

Output:
     int unusedOffset = 0;
-    int entryLength = nicknameLength + otLength + 10;
+    int entryLength = nicknameLength + otLength + 9;
+    if (entryLength % 2 != 0) {
+        entryLength++;
+    }
     for (int entry = 0; entry < tableSize; entry++) {


Input:
public void onEnable() {
    setupDatabase();
    warpManager = new WarpManager(getDatabase());
    getCommand(AppStrings.COMMAND_ADD).setExecutor(new AddWarpCommand(this));
    getCommand(AppStrings.COMMAND_ADMIN).setExecutor(new AdminCommand(this));
    getCommand(AppStrings.COMMAND_LIST).setExecutor(new ListWarpsCommand(this));
    getCommand(AppStrings.COMMAND_DELETE).setExecutor(new DeleteWarpCommand(this));
    getCommand(AppStrings.COMMAND_RENAME).setExecutor(new RenameWarpCommand(this));
    getCommand(AppStrings.COMMAND_SET).setExecutor(new SetWarpTypeCommand(this));
    getCommand(AppStrings.COMMAND_WARP).setExecutor(new WarpCommand(this));
    this.setupPermissions();
    log.info(AppStrings.getEnabledMessage(this));
}

Output:
     setupDatabase();
-    warpManager = new WarpManager(getDatabase());
+    warpManager = new WarpManager(this);
     getCommand(AppStrings.COMMAND_ADD).setExecutor(new AddWarpCommand(this));


Input:
public void execute(AdminCommandContext context) {
    ActionReport report = context.getActionReport();
    ctx = context;
    logger = context.logger;
    String msg = "String_Node_Str";
    boolean fsfailure = false;
    boolean configfailure = false;
    instance = servers.getServer(instanceName);
    if (instance == null) {
        msg = Strings.get("String_Node_Str", instanceName);
        logger.warning(msg);
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        report.setMessage(msg);
        return;
    }
    instanceHost = instance.getAdminHost();
    if (instance.isRunning()) {
        msg = Strings.get("String_Node_Str", instanceName);
        logger.warning(msg);
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        report.setMessage(msg);
        return;
    }
    noderef = instance.getNodeRef();
    if (!StringUtils.ok(noderef)) {
        msg = Strings.get("String_Node_Str", instanceName);
        fsfailure = true;
    } else {
        theNode = nodes.getNode(noderef);
        if (theNode == null) {
            msg = Strings.get("String_Node_Str", noderef);
            fsfailure = true;
        }
    }
    if (!fsfailure) {
        nodedir = theNode.getNodeDirAbsolute();
        deleteInstanceFilesystem(context);
        report = context.getActionReport();
        if (report.getActionExitCode() != ActionReport.ExitCode.SUCCESS) {
            fsfailure = true;
        }
        msg = report.getMessage();
    }
    CommandInvocation ci = cr.getCommandInvocation("String_Node_Str", report);
    ParameterMap map = new ParameterMap();
    map.add("String_Node_Str", instanceName);
    ci.parameters(map);
    ci.execute();
    if (report.getActionExitCode() != ActionReport.ExitCode.SUCCESS && report.getActionExitCode() != ActionReport.ExitCode.WARNING) {
        configfailure = true;
        if (fsfailure) {
            msg = msg + NL + report.getMessage();
        } else {
            msg = report.getMessage();
        }
    }
    if (configfailure && fsfailure) {
        msg = msg + NL + NL + Strings.get("String_Node_Str", instanceName, instanceHost);
    } else if (configfailure && !fsfailure) {
        msg = msg + NL + NL + Strings.get("String_Node_Str", instanceName, instanceHost);
    } else if (!configfailure && fsfailure) {
        report.setActionExitCode(ActionReport.ExitCode.WARNING);
    }
    if (configfailure) {
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        report.setMessage(msg);
    }
}

Output:
         nodedir = theNode.getNodeDirAbsolute();
-        deleteInstanceFilesystem(context);
-        report = context.getActionReport();
+        deleteInstanceFilesystem(ctx);
+        report = ctx.getActionReport();
         if (report.getActionExitCode() != ActionReport.ExitCode.SUCCESS) {


Input:
public synchronized PersistenceAdapter createNewPersistenceAdapterInstance() {
    if (persistenceAdapterClass == null) {
        final String classStr = (String) topologyConfig.get(SidelineSpoutConfig.PERSISTENCE_ADAPTER_CLASS);
        if (Strings.isNullOrEmpty(classStr)) {
            throw new IllegalStateException("String_Node_Str" + SidelineSpoutConfig.PERSISTENCE_ADAPTER_CLASS);
        }
        try {
            persistenceAdapterClass = (Class<? extends PersistenceAdapter>) Class.forName(classStr);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
    try {
        return persistenceAdapterClass.newInstance();
    } catch (IllegalAccessException | InstantiationException e) {
        throw new RuntimeException(e);
    }
}

Output:
     if (persistenceAdapterClass == null) {
-        final String classStr = (String) topologyConfig.get(SidelineSpoutConfig.PERSISTENCE_ADAPTER_CLASS);
+        final String classStr = (String) spoutConfig.get(SidelineSpoutConfig.PERSISTENCE_ADAPTER_CLASS);
         if (Strings.isNullOrEmpty(classStr)) {


Input:
protected SOWrapper makeNewSharedObjectWrapper(SharedObjectDescription sd, ISharedObject s) {
    SOConfig newConfig = makeNewSharedObjectConfig(sd, this);
    return new SOWrapper(newConfig, s, this);
}

Output:
 protected SOWrapper makeNewSharedObjectWrapper(SharedObjectDescription sd, ISharedObject s) {
-    SOConfig newConfig = makeNewSharedObjectConfig(sd, this);
+    SOConfig newConfig = makeNewSharedObjectConfig(sd, s);
     return new SOWrapper(newConfig, s, this);


Input:
public void put(Object key, Object value) {
    ehcache.put(new Element(key, value));
}

Output:
 public void put(Object key, Object value) {
-    ehcache.put(new Element(key, value));
+    if (isAlive())
+        ehcache.put(new Element(key, value));
 }


Input:
public void Finalize() throws CarriageMotionException {
    for (BlockRecord PotentialObstruction : PotentialObstructions) {
        AssertNotObstruction(PotentialObstruction);
    }
    long WorldTime = World.getWorldInfo().getWorldTotalTime();
    try {
        java.util.Iterator PendingBlockUpdateSetIterator = World.pendingTickListEntriesTreeSet.iterator();
        while (PendingBlockUpdateSetIterator.hasNext()) {
            net.minecraft.world.NextTickListEntry PendingBlockUpdate = (net.minecraft.world.NextTickListEntry) PendingBlockUpdateSetIterator.next();
            if (Body.contains(new BlockRecord(PendingBlockUpdate.xCoord, PendingBlockUpdate.yCoord, PendingBlockUpdate.zCoord))) {
                PendingBlockUpdateSetIterator.remove();
                World.pendingTickListEntriesHashSet.remove(PendingBlockUpdate);
                StorePendingBlockUpdateRecord(PendingBlockUpdate, WorldTime);
            }
        }
    } catch (Throwable VanillaThrowable) {
        if (VanillaThrowable instanceof ThreadDeath) {
            throw ((ThreadDeath) VanillaThrowable);
        }
        try {
            java.util.Set PendingBlockUpdateSet = (java.util.Set) ModInteraction.PendingBlockUpdateSetField.get(World);
            while (true) {
                net.minecraft.world.NextTickListEntry PendingBlockUpdate = null;
                for (Object Target : PendingBlockUpdateSet) {
                    net.minecraft.world.NextTickListEntry TargetPendingBlockUpdate = (net.minecraft.world.NextTickListEntry) Target;
                    if (Body.contains(new BlockRecord(TargetPendingBlockUpdate.xCoord, TargetPendingBlockUpdate.yCoord, TargetPendingBlockUpdate.zCoord))) {
                        PendingBlockUpdate = TargetPendingBlockUpdate;
                        break;
                    }
                }
                if (PendingBlockUpdate == null) {
                    break;
                }
                StorePendingBlockUpdateRecord(PendingBlockUpdate, WorldTime);
                ModInteraction.RemovePendingBlockUpdate.invoke(World, PendingBlockUpdate);
            }
        } catch (Throwable McpcThrowable) {
            McpcThrowable.printStackTrace();
            VanillaThrowable.printStackTrace();
        }
    }
    if (Configuration.HardmodeActive) {
        for (BlockRecord CarriageRecord : Carriages) {
            int Tier = ((CarriageEntity) CarriageRecord.Entity).Tier;
            double Factor = Carriage.Tiers.values()[Tier].CargoBurdenFactor;
            if (Tier == 0) {
                for (Directions Direction : Directions.values()) {
                    BlockRecord Position = CarriageRecord.NextInDirection(Direction);
                    ApplyCargoBurdenFactor(Position, Factor);
                }
            } else {
                for (int Distance = 1; Distance <= Tier; Distance++, Factor = Math.sqrt(Factor)) {
                    int MinX = CarriageRecord.X - Distance;
                    int MinY = CarriageRecord.Y - Distance;
                    int MinZ = CarriageRecord.Z - Distance;
                    int MaxX = CarriageRecord.X + Distance;
                    int MaxY = CarriageRecord.Y + Distance;
                    int MaxZ = CarriageRecord.Z + Distance;
                    for (int X = MinX; X <= MaxX; X++) {
                        for (int Y = MinY; Y <= MaxY; Y++) {
                            for (int Z = MinZ; Z <= MaxZ; Z++) {
                                if ((X == MinX) || (X == MaxX) || (Y == MinY) || (Y == MaxY) || (Z == MinZ) || (Z == MaxZ)) {
                                    ApplyCargoBurdenFactor(new BlockRecord(X, Y, Z), Factor);
                                }
                            }
                        }
                    }
                }
            }
        }
        for (BlockRecord CargoRecord : Cargo) {
            Double BurdenFactor = CargoBurdenFactors.get(CargoRecord);
            double Burden = GetBaseBurden(CargoRecord);
            if (BurdenFactor == null) {
                Mass += Burden;
            } else {
                Mass += Burden * BurdenFactor;
            }
        }
    }
    PotentialObstructions = null;
    Carriages = null;
    Cargo = null;
    CargoBurdenFactors = null;
}

Output:
     try {
-        java.util.Iterator PendingBlockUpdateSetIterator = World.pendingTickListEntriesTreeSet.iterator();
+        java.util.Iterator PendingBlockUpdateSetIterator = ((TreeSet<BlockRecord>) Reflection.stealField("String_Node_Str", World)).iterator();
         while (PendingBlockUpdateSetIterator.hasNext()) {


Input:
public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
    int id = IdGenerator.getInstance().getUnique(attributeValue);
    Integer rule = relativeLayoutParams.get(attributeKey);
    ParseHelper.addRelativeLayoutRule(view, rule, id);
}

Output:
     Integer rule = relativeLayoutParams.get(attributeKey);
-    ParseHelper.addRelativeLayoutRule(view, rule, id);
+    if (rule != null) {
+        ParseHelper.addRelativeLayoutRule(view, rule, id);
+    }
 }


Input:
public void testMissingInformation() throws IOException {
    File jar = folder.newFile("String_Node_Str");
    SimpleIndexSearcher mockedIndexer = mock(SimpleIndexSearcher.class);
    when(mockedIndexer.searchByFingerprint(Fingerprints.sha1(jar))).thenReturn(fromNullable("String_Node_Str"));
    FingerprintStrategy sut = new FingerprintStrategy(mockedIndexer);
    Optional<ProjectCoordinate> optionalProjectCoordinate = sut.searchForProjectCoordinate(new DependencyInfo(jar, DependencyType.JAR));
    Assert.assertFalse(optionalProjectCoordinate.isPresent());
}

Output:
     SimpleIndexSearcher mockedIndexer = mock(SimpleIndexSearcher.class);
-    when(mockedIndexer.searchByFingerprint(Fingerprints.sha1(jar))).thenReturn(fromNullable("String_Node_Str"));
+    when(mockedIndexer.searchByFingerprint(Fingerprints.sha1(exampleFile))).thenReturn(fromNullable("String_Node_Str"));
     FingerprintStrategy sut = new FingerprintStrategy(mockedIndexer);


Input:
protected List<URL> getExternalLibraries(boolean needLibraries, ExportFileResource[] process, Set<String> neededLibraries) {
    List<URL> list = new ArrayList<URL>();
    if (!needLibraries) {
        return list;
    }
    IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
    IProject prj = root.getProject(JavaUtils.JAVA_PROJECT_NAME);
    IJavaProject project = JavaCore.create(prj);
    IPath libPath = project.getResource().getLocation().append(JavaUtils.JAVA_LIB_DIRECTORY);
    File file = libPath.toFile();
    if (!file.exists()) {
        file.mkdir();
    }
    File[] files = file.listFiles(FilesUtils.getAcceptModuleFilesFilter());
    Set<String> listModulesReallyNeeded = new HashSet<String>();
    if (neededLibraries == null) {
        IDesignerCoreService designerService = RepositoryPlugin.getDefault().getDesignerCoreService();
        for (int i = 0; i < process.length; i++) {
            ExportFileResource resource = process[i];
            ProcessItem item = (ProcessItem) resource.getItem();
            String version = item.getProperty().getVersion();
            if (!isMultiNodes() && this.getSelectedJobVersion() != null) {
                version = this.getSelectedJobVersion();
            }
            ProcessItem selectedProcessItem;
            if (resource.getNode() != null) {
                selectedProcessItem = ItemCacheManager.getProcessItem(resource.getNode().getRoot().getProject(), item.getProperty().getId(), version);
            } else {
                selectedProcessItem = ItemCacheManager.getProcessItem(item.getProperty().getId(), version);
            }
            IProcess iProcess = designerService.getProcessFromProcessItem(selectedProcessItem);
            neededLibraries = iProcess.getNeededLibraries(true);
            if (neededLibraries != null) {
                listModulesReallyNeeded.addAll(neededLibraries);
            }
        }
    } else {
        listModulesReallyNeeded.addAll(neededLibraries);
    }
    List<IRepositoryViewObject> collectRoutines = new ArrayList<IRepositoryViewObject>();
    boolean useBeans = false;
    if (GlobalServiceRegister.getDefault().isServiceRegistered(ICamelDesignerCoreService.class)) {
        ICamelDesignerCoreService camelService = (ICamelDesignerCoreService) GlobalServiceRegister.getDefault().getService(ICamelDesignerCoreService.class);
        if (camelService.isInstanceofCamel(process[0].getItem())) {
            useBeans = true;
        }
    }
    collectRoutines.addAll(collectRoutines(process, useBeans));
    for (IRepositoryViewObject object : collectRoutines) {
        Item item = object.getProperty().getItem();
        if (item instanceof RoutineItem) {
            RoutineItem routine = (RoutineItem) item;
            EList imports = routine.getImports();
            for (Object o : imports) {
                IMPORTType type = (IMPORTType) o;
                listModulesReallyNeeded.add(type.getMODULE());
            }
        }
    }
    for (int i = 0; i < files.length; i++) {
        File tempFile = files[i];
        try {
            if (listModulesReallyNeeded.contains(tempFile.getName())) {
                list.add(tempFile.toURL());
            }
        } catch (MalformedURLException e) {
            ExceptionHandler.process(e);
        }
    }
    return list;
}

Output:
         IDesignerCoreService designerService = RepositoryPlugin.getDefault().getDesignerCoreService();
-        for (int i = 0; i < process.length; i++) {
-            ExportFileResource resource = process[i];
+        for (ExportFileResource resource : process) {
             ProcessItem item = (ProcessItem) resource.getItem();


Input:
public void display(GL2 gl) {
    if (!uninitializedDimensionGroups.isEmpty()) {
        while (uninitializedDimensionGroups.peek() != null) {
            uninitializedDimensionGroups.poll().initRemote(gl, this, glMouseListener);
        }
        initLayouts();
    }
    if (isDisplayListDirty) {
        buildDisplayList(gl, displayListIndex);
        isDisplayListDirty = false;
    }
    for (DimensionGroup group : dimensionGroupManager.getDimensionGroups()) {
        group.processEvents();
    }
    handleHorizontalMoveDragging(gl);
    if (isLayoutDirty) {
        isLayoutDirty = false;
        centerLayoutManager.updateLayout();
        float minWidth = pixelGLConverter.getGLWidthForPixelWidth(DIMENSION_GROUP_SPACING_MIN_PIXEL_WIDTH);
        for (ElementLayout layout : centerRowLayout) {
            if (!(layout.getRenderer() instanceof DimensionGroupSpacingRenderer))
                continue;
            if (resizeNecessary)
                break;
            if (layout.getSizeScaledX() < minWidth - 0.01f) {
                resizeNecessary = true;
                break;
            }
        }
    }
    if (resizeNecessary) {
        int size = centerRowLayout.size();
        if (size >= 3) {
            if (lastResizeDirectionWasToLeft) {
                dimensionGroupManager.setCenterGroupStartIndex(dimensionGroupManager.getCenterGroupStartIndex() + 1);
                float width = centerRowLayout.getElements().get(0).getSizeScaledX() + centerRowLayout.getElements().get(1).getSizeScaledX() + centerRowLayout.getElements().get(2).getSizeScaledX();
                centerRowLayout.remove(0);
                centerRowLayout.remove(0);
                leftDimensionGroupSpacing = centerRowLayout.getElements().get(0);
                leftDimensionGroupSpacing.setAbsoluteSizeX(width);
                ((DimensionGroupSpacingRenderer) leftDimensionGroupSpacing.getRenderer()).setLeftDimGroup(null);
                initLeftLayout();
            } else {
                dimensionGroupManager.setRightGroupStartIndex(dimensionGroupManager.getRightGroupStartIndex() - 1);
                centerRowLayout.remove(centerRowLayout.size() - 1);
                centerRowLayout.remove(centerRowLayout.size() - 1);
                rightDimensionGroupSpacing = centerRowLayout.getElements().get(centerRowLayout.size() - 1);
                rightDimensionGroupSpacing.setGrabX(true);
                ((DimensionGroupSpacingRenderer) rightDimensionGroupSpacing.getRenderer()).setRightDimGroup(null);
                initRightLayout();
            }
        }
        centerLayoutManager.updateLayout();
        resizeNecessary = false;
    }
    for (DimensionGroup dimensionGroup : dimensionGroupManager.getDimensionGroups()) {
        dimensionGroup.display(gl);
    }
    if (isConnectionLinesDirty)
        performConnectionLinesUpdate();
    if (showArchSides && !isRightDetailShown && !isLeftDetailShown) {
        leftLayoutManager.render(gl);
    }
    gl.glTranslatef(archInnerWidth, 0, 0);
    centerLayoutManager.render(gl);
    gl.glTranslatef(-archInnerWidth, 0, 0);
    if (showArchSides && !isRightDetailShown && !isLeftDetailShown) {
        float rightArchStand = (1 - ARCH_STAND_WIDTH_PERCENT) * viewFrustum.getWidth();
        gl.glTranslatef(rightArchStand, 0, 0);
        rightLayoutManager.render(gl);
        gl.glTranslatef(-rightArchStand, 0, 0);
    }
    if (showArchSides && !isRightDetailShown && !isLeftDetailShown) {
        renderArch(gl);
    }
    dragAndDropController.handleDragging(gl, glMouseListener);
}

Output:
     }
-    handleHorizontalMoveDragging(gl);
+    handleHorizontalColumnMove(gl);
     if (isLayoutDirty) {


Input:
boolean putEntry(long newHashEntryAdr, long hash, long keyLen, long bytes, boolean ifAbsent, long oldValueAdr, long oldValueLen) {
    long removeHashEntryAdr = 0L;
    LongArrayList derefList = null;
    lock.lock();
    try {
        long oldHashEntryAdr = 0L;
        long hashEntryAdr;
        long prevEntryAdr = 0L;
        for (hashEntryAdr = table.getFirst(hash); hashEntryAdr != 0L; prevEntryAdr = hashEntryAdr, hashEntryAdr = HashEntries.getNext(hashEntryAdr)) {
            if (notSameKey(newHashEntryAdr, hash, keyLen, hashEntryAdr))
                continue;
            if (ifAbsent)
                return false;
            if (oldValueAdr != 0L) {
                long valueLen = HashEntries.getValueLen(hashEntryAdr);
                if (valueLen != oldValueLen || !HashEntries.compare(hashEntryAdr, Util.ENTRY_OFF_DATA + Util.roundUpTo8(keyLen), oldValueAdr, 0L, oldValueLen))
                    return false;
            }
            removeInternal(hashEntryAdr, prevEntryAdr);
            removeHashEntryAdr = hashEntryAdr;
            oldHashEntryAdr = hashEntryAdr;
            break;
        }
        while (freeCapacity < bytes) {
            long eldestHashAdr = removeEldest();
            if (eldestHashAdr == 0L) {
                if (oldHashEntryAdr != 0L)
                    size--;
                return false;
            }
            if (derefList == null)
                derefList = new LongArrayList();
            derefList.add(eldestHashAdr);
        }
        if (hashEntryAdr == 0L) {
            if (size >= threshold)
                rehash();
            size++;
        }
        freeCapacity -= bytes;
        add(newHashEntryAdr, hash);
        if (hashEntryAdr == 0L)
            putAddCount++;
        else
            putReplaceCount++;
        return true;
    } finally {
        lock.unlock();
        if (removeHashEntryAdr != 0L)
            HashEntries.dereference(removeHashEntryAdr);
        if (derefList != null)
            for (int i = 0; i < derefList.size(); i++) HashEntries.dereference(derefList.getLong(i));
    }
}

Output:
                 return false;
-            if (oldValueAdr != 0L) {
+            if (oldValueAddr != 0L) {
                 long valueLen = HashEntries.getValueLen(hashEntryAdr);


Input:
public Promise<AuthorizationResult, ResourceException> authorizeDelete(ServerContext serverContext, DeleteRequest deleteRequest) {
    final String resource = ServerContextUtils.getMatchedUri(serverContext);
    final String action = ServerContextUtils.getDeleteString(deleteRequest);
    return log(resource, action, ServerContextUtils.getTokenFromContext(serverContext), module.authorizeDelete(serverContext, deleteRequest), moduleName);
}

Output:
     final String action = ServerContextUtils.getDeleteString(deleteRequest);
-    return log(resource, action, ServerContextUtils.getTokenFromContext(serverContext), module.authorizeDelete(serverContext, deleteRequest), moduleName);
+    return log(resource, action, ServerContextUtils.getTokenFromContext(serverContext, debug), module.authorizeDelete(serverContext, deleteRequest), moduleName);
 }


Input:
public static void setTagNewestDate(String tagName, String date) {
    if (TextUtils.isEmpty(tagName))
        return;
    ContentValues values = new ContentValues();
    values.put("String_Node_Str", tagName);
    values.put("String_Node_Str", date);
    try {
        ReaderDatabase.getWritableDb().insertWithOnConflict("String_Node_Str", null, values, SQLiteDatabase.CONFLICT_REPLACE);
    } catch (SQLException e) {
        AppLog.e(T.READER, e);
    }
}

Output:
 public static void setTagNewestDate(String tagName, String date) {
-    if (TextUtils.isEmpty(tagName))
+    if (TextUtils.isEmpty(tagName)) {
         return;


Input:
private void addSorting(ICubeQueryDefinition cubeQuery, CubeHandle cube, SeriesDefinition sd, int i) throws BirtException {
    if (sd.getSortKey() == null) {
        return;
    }
    String sortKey = sd.getSortKey().getDefinition();
    if (sd.isSetSorting() && sortKey != null && sortKey.length() > 0) {
        String sortKeyBinding = ChartExpressionUtil.getCubeBindingName(sd.getSortKey().getDefinition(), true);
        if (registeredLevels.containsKey(sortKeyBinding)) {
            ICubeSortDefinition sortDef = getCubeElementFactory().createCubeSortDefinition(sortKey, registeredLevels.get(sortKeyBinding), null, null, sd.getSorting() == SortOption.ASCENDING_LITERAL ? ISortDefinition.SORT_ASC : ISortDefinition.SORT_DESC);
            cubeQuery.addSort(sortDef);
        } else if (registeredMeasures.containsKey(sortKeyBinding)) {
            Query targetQuery = i > 0 ? sd.getQuery() : (Query) sd.getDesignTimeSeries().getDataDefinition().get(0);
            IMeasureDefinition mDef = registeredMeasures.get(sortKeyBinding);
            String targetBindingName = ChartExpressionUtil.getCubeBindingName(targetQuery.getDefinition(), true);
            IBinding measureBinding = registeredBindings.get(sortKeyBinding);
            IBinding aggBinding = new Binding(measureBinding.getBindingName() + targetBindingName);
            aggBinding.setDataType(measureBinding.getDataType());
            aggBinding.setExpression(measureBinding.getExpression());
            aggBinding.addAggregateOn(registeredQueries.get(targetBindingName));
            aggBinding.setAggrFunction(mDef.getAggrFunction());
            aggBinding.setExportable(false);
            cubeQuery.addBinding(aggBinding);
            ICubeSortDefinition sortDef = getCubeElementFactory().createCubeSortDefinition(ExpressionUtil.createJSDataExpression(aggBinding.getBindingName()), registeredLevels.get(targetBindingName), null, null, sd.getSorting() == SortOption.ASCENDING_LITERAL ? ISortDefinition.SORT_ASC : ISortDefinition.SORT_DESC);
            cubeQuery.addSort(sortDef);
        }
    }
}

Output:
         if (registeredLevels.containsKey(sortKeyBinding)) {
-            ICubeSortDefinition sortDef = getCubeElementFactory().createCubeSortDefinition(sortKey, registeredLevels.get(sortKeyBinding), null, null, sd.getSorting() == SortOption.ASCENDING_LITERAL ? ISortDefinition.SORT_ASC : ISortDefinition.SORT_DESC);
+            ICubeSortDefinition sortDef = getCubeElementFactory().createCubeSortDefinition(sortKey.trim(), registeredLevels.get(sortKeyBinding), null, null, sd.getSorting() == SortOption.ASCENDING_LITERAL ? ISortDefinition.SORT_ASC : ISortDefinition.SORT_DESC);
             cubeQuery.addSort(sortDef);