Input:
public CommandHandler getCommands() {
    return new BlacksmithCommands();
}

Output:
 public CommandHandler getCommands() {
-    return new BlacksmithCommands();
+    return BlacksmithCommands.INSTANCE;
 }


Input:
protected void setupDatabase(Database database) throws Exception {
    dropAndCreateTable(new CreateTableStatement(TABLE_NAME).addPrimaryKeyColumn("String_Node_Str", "String_Node_Str").addColumn(COL_NAME, "String_Node_Str", new NotNullConstraint(), new UniqueConstraint(CONSTRAINT_NAME)), database);
}

Output:
 protected void setupDatabase(Database database) throws Exception {
-    dropAndCreateTable(new CreateTableStatement(TABLE_NAME).addPrimaryKeyColumn("String_Node_Str", "String_Node_Str").addColumn(COL_NAME, "String_Node_Str", new NotNullConstraint(), new UniqueConstraint(CONSTRAINT_NAME)), database);
+    dropAndCreateTable(new CreateTableStatement(null, TABLE_NAME).addPrimaryKeyColumn("String_Node_Str", "String_Node_Str").addColumn(COL_NAME, "String_Node_Str", new NotNullConstraint(), new UniqueConstraint(CONSTRAINT_NAME)), database);
 }


Input:
private void _removeEditorIcons() {
    for (Object editorIconObject : attributeList(EditorIcon.class)) {
        EditorIcon editorIcon = (EditorIcon) editorIconObject;
        String moml = "String_Node_Str" + editorIcon.getName() + "String_Node_Str";
        requestChange(new MoMLChangeRequest(this, this, moml));
    }
}

Output:
         String moml = "String_Node_Str" + editorIcon.getName() + "String_Node_Str";
-        requestChange(new MoMLChangeRequest(this, this, moml));
+        new MoMLChangeRequest(this, AtomicActorMatcher.this, moml).execute();
     }


Input:
private void testBufferedTo(Method m) {
    Class[] paramTypes = m.getParameterTypes();
    BufferedImage[] input;
    input = createBufferedTestImages(paramTypes[0]);
    for (int i = 0; i < input.length; i++) {
        ImageBase output = createImage(m, paramTypes[1], input[i]);
        BoofTesting.checkSubImage(this, "String_Node_Str", true, m, input[i], output);
        BufferedImage subimage = input[i].getSubimage(1, 2, imgWidth - 1, imgHeight - 2);
        output = createImage(m, paramTypes[1], subimage);
        BoofTesting.checkSubImage(this, "String_Node_Str", true, m, subimage, output);
    }
}

Output:
         BoofTesting.checkSubImage(this, "String_Node_Str", true, m, input[i], output);
-        BufferedImage subimage = input[i].getSubimage(1, 2, imgWidth - 1, imgHeight - 2);
-        output = createImage(m, paramTypes[1], subimage);
-        BoofTesting.checkSubImage(this, "String_Node_Str", true, m, subimage, output);
+        if (canSubImage) {
+            BufferedImage subimage = input[i].getSubimage(1, 2, imgWidth - 1, imgHeight - 2);
+            output = createImage(m, paramTypes[1], subimage);
+            BoofTesting.checkSubImage(this, "String_Node_Str", true, m, subimage, output);
+        }
     }


Input:
public String toString() {
    String toString = (getApplicationName() + "String_Node_Str" + getApplicationVersion()).trim();
    if (toString.isEmpty()) {
        super.toString();
    }
    return toString;
}

Output:
     String toString = (getApplicationName() + "String_Node_Str" + getApplicationVersion()).trim();
-    if (toString.isEmpty()) {
-        super.toString();
-    }
-    return toString;
+    return toString.isEmpty() ? super.toString() : toString;
 }


Input:
private void processExtension(String targetNamespace, String defaultNamespace, SDOType owningType, Extension extension, boolean simpleContent) {
    if (extension != null) {
        String qualifiedType = extension.getBaseType();
        processBaseType(targetNamespace, defaultNamespace, owningType, qualifiedType, simpleContent);
        if (extension.getChoice() != null) {
            processChoice(targetNamespace, defaultNamespace, owningType, extension.getChoice(), false);
        } else if (extension.getSequence() != null) {
            processSequence(targetNamespace, defaultNamespace, owningType, extension.getSequence(), false);
        } else if (extension.getAll() != null) {
        }
        processOrderedAttributes(targetNamespace, defaultNamespace, owningType, extension.getOrderedAttributes());
    }
}

Output:
         String qualifiedType = extension.getBaseType();
-        processBaseType(targetNamespace, defaultNamespace, owningType, qualifiedType, simpleContent);
+        if (qualifiedType != null) {
+            SDOType baseType = getSDOTypeForName(targetNamespace, defaultNamespace, qualifiedType);
+            processBaseType(baseType, targetNamespace, defaultNamespace, owningType, qualifiedType, simpleContent);
+        }
         if (extension.getChoice() != null) {


Input:
private void ifTimeSeriesFeatureCollection(StationTimeSeriesFeatureCollection featureCollection, List<String> observedPropertyList) throws IOException {
    String stationName = null;
    String stationLat = null;
    String stationLon = null;
    SOSObservationOffering newOffering = null;
    StationTimeSeriesFeature feature = null;
    List<Station> stationList = featureCollection.getStations();
    for (int i = 0; i < stationList.size(); i++) {
        feature = featureCollection.getStationFeature(stationList.get(i));
        stationName = stationList.get(i).getName();
        stationLat = formatDegree(stationList.get(i).getLatitude());
        stationLon = formatDegree(stationList.get(i).getLongitude());
        newOffering = new SOSObservationOffering();
        newOffering.setObservationStationID(getGMLID(stationName));
        newOffering.setObservationStationLowerCorner(stationLat, stationLon);
        newOffering.setObservationStationUpperCorner(stationLat, stationLon);
        if (stationList.size() < 75) {
            feature.calcBounds();
            newOffering.setObservationTimeBegin(feature.getDateRange().getStart().toDateTimeStringISO());
            newOffering.setObservationTimeEnd(feature.getDateRange().getEnd().toDateTimeStringISO());
        }
        newOffering.setObservationStationDescription(feature.getDescription());
        newOffering.setObservationName(getGMLName((stationName)));
        newOffering.setObservationSrsName("String_Node_Str");
        newOffering.setObservationProcedureLink(getGMLName((stationName)));
        newOffering.setObservationObserveredList(observedPropertyList);
        newOffering.setObservationFeatureOfInterest(getFeatureOfInterest(stationName));
        newOffering.setObservationFormat(format);
        addObsOfferingToDoc(newOffering);
    }
}

Output:
         newOffering.setObservationStationUpperCorner(stationLat, stationLon);
-        if (stationList.size() < 75) {
+        try {
             feature.calcBounds();


Input:
public TileEntityCoffin getPrimaryTileEntity() {
    if ((this.worldObj.getBlockMetadata(this.otherX, this.yCoord, this.zCoord) & -8) == 0)
        return (TileEntityCoffin) worldObj.getTileEntity(otherX, otherY, otherZ);
    return this;
}

Output:
 public TileEntityCoffin getPrimaryTileEntity() {
-    if ((this.worldObj.getBlockMetadata(this.otherX, this.yCoord, this.zCoord) & -8) == 0)
+    if ((this.getBlockMetadata() & -8) == 0)
         return (TileEntityCoffin) worldObj.getTileEntity(otherX, otherY, otherZ);


Input:
private void fill() {
    List<Form> allForms = flattenedSolution.getFormHierarchy(form);
    copyPropertiesMap(form.getPropertiesMap(), false);
    Set<String> methods = new HashSet<String>(64);
    Set<String> variables = new HashSet<String>(64);
    List<Integer> existingIDs = new ArrayList<Integer>();
    for (Form f : allForms) {
        for (IPersist ip : f.getAllObjectsAsList()) {
            Integer extendsID = (ip instanceof ISupportExtendsID) ? new Integer(((ISupportExtendsID) ip).getExtendsID()) : Integer.valueOf(-1);
            if (!existingIDs.contains(new Integer(ip.getID())) && !existingIDs.contains(extendsID)) {
                if (ip instanceof ISupportExtendsID && PersistHelper.isOverrideOrphanElement((ISupportExtendsID) ip)) {
                    continue;
                }
                boolean addScriptMethod = (ip instanceof ScriptMethod && methods.add(((ScriptMethod) ip).getName()));
                boolean addScriptVariable = (ip instanceof ScriptVariable && variables.add(((ScriptVariable) ip).getName()));
                boolean addOtherElement = (!(ip instanceof Part) && !(ip instanceof ScriptMethod) && !(ip instanceof ScriptVariable));
                if (addScriptVariable || addScriptMethod || addOtherElement) {
                    if (ip instanceof TabPanel) {
                        internalAddChild(new FlattenedTabPanel((TabPanel) ip));
                    } else if (ip instanceof Portal) {
                        internalAddChild(new FlattenedPortal((Portal) ip));
                    } else {
                        internalAddChild(ip);
                    }
                }
            }
            if (ip instanceof ISupportExtendsID && PersistHelper.isOverrideElement((ISupportExtendsID) ip) && !existingIDs.contains(extendsID)) {
                existingIDs.add(extendsID);
            }
        }
    }
    Part prevPart = null;
    Collections.reverse(allForms);
    for (Form f : allForms) {
        Iterator<Part> parts = f.getParts();
        while (parts.hasNext()) {
            Part part = parts.next();
            if (PersistHelper.isOverrideElement(part)) {
                Part parentPart = null;
                Iterator<Part> it = getParts();
                while (it.hasNext()) {
                    Part temp = it.next();
                    if (temp.getID() == part.getExtendsID() || temp.getExtendsID() == part.getExtendsID()) {
                        parentPart = temp;
                        break;
                    }
                }
                if (parentPart != null) {
                    internalAddChild(part);
                    internalRemoveChild(parentPart);
                }
            } else {
                internalAddChild(part);
                prevPart = part;
            }
        }
    }
    setSize(checkParts(getParts(), getSize()));
}

Output:
             } else {
-                internalAddChild(part);
-                prevPart = part;
+                if (prevPart == null || prevPart.getPartType() < part.getPartType() || (prevPart.getPartType() == part.getPartType() && part.canBeMoved())) {
+                    internalAddChild(part);
+                    prevPart = part;
+                }
             }


Input:
public void testEmployeeGeneration() {
    if (shouldGenerateSchema) {
        outputResolver = generateSchema(CONTEXT_PATH, 2);
        shouldGenerateSchema = false;
    }
    String messages = "String_Node_Str";
    String src = PATH + "String_Node_Str";
    String result = validateAgainstSchema(src, EMPTY_NAMESPACE, outputResolver);
    assertTrue("String_Node_Str" + result, result == null);
}

Output:
     if (shouldGenerateSchema) {
-        outputResolver = generateSchema(CONTEXT_PATH, 2);
+        outputResolver = generateSchema(CONTEXT_PATH, PATH, 2);
         shouldGenerateSchema = false;


Input:
public void should_not_fail_on_empty_file() {
    SonarScanner build = SonarScanner.create().setProjectKey(EMPTY_FILE_PROJET_KEY).setProjectName("String_Node_Str").setProjectVersion("String_Node_Str").setSourceEncoding("String_Node_Str").setSourceDirs("String_Node_Str").setProjectDir(Tests.projectDirectoryFor("String_Node_Str"));
    orchestrator.executeBuild(build);
    assertThat(getMeasureAsInt(EMPTY_FILE_PROJET_KEY, "String_Node_Str")).isEqualTo(3);
}

Output:
     SonarScanner build = SonarScanner.create().setProjectKey(EMPTY_FILE_PROJET_KEY).setProjectName("String_Node_Str").setProjectVersion("String_Node_Str").setSourceEncoding("String_Node_Str").setSourceDirs("String_Node_Str").setProjectDir(Tests.projectDirectoryFor("String_Node_Str"));
-    orchestrator.executeBuild(build);
+    Tests.executeBuildWithExpectedWarnings(orchestrator, build);
     assertThat(getMeasureAsInt(EMPTY_FILE_PROJET_KEY, "String_Node_Str")).isEqualTo(3);


Input:
public void startRequest(MRCRequest rq) {
    try {
        final xtreemfs_replica_addRequest rqArgs = (xtreemfs_replica_addRequest) rq.getRequestArgs();
        final FileAccessManager faMan = master.getFileAccessManager();
        final VolumeManager vMan = master.getVolumeManager();
        validateContext(rq);
        long fileId = 0;
        String volumeId = null;
        try {
            String globalFileId = rqArgs.getFile_id();
            int i = globalFileId.indexOf(':');
            volumeId = rqArgs.getFile_id().substring(0, i);
            fileId = Long.parseLong(rqArgs.getFile_id().substring(i + 1));
        } catch (Exception exc) {
            throw new UserException("String_Node_Str" + rqArgs.getFile_id() + "String_Node_Str");
        }
        StorageManager sMan = vMan.getStorageManager(volumeId);
        FileMetadata file = sMan.getMetadata(fileId);
        if (file == null)
            throw new UserException(ErrNo.ENOENT, "String_Node_Str" + fileId + "String_Node_Str");
        String target = sMan.getSoftlinkTarget(file.getId());
        if (target != null) {
            String path = target;
            Path p = new Path(path);
            if (!vMan.hasVolume(p.getComp(0))) {
                finishRequest(rq, new ErrorRecord(ErrorClass.USER_EXCEPTION, ErrNo.ENOENT, "String_Node_Str" + target + "String_Node_Str"));
                return;
            }
            VolumeInfo volume = vMan.getVolumeByName(p.getComp(0));
            sMan = vMan.getStorageManager(volume.getId());
            PathResolver res = new PathResolver(sMan, p);
            file = res.getFile();
        }
        if (file.isDirectory())
            throw new UserException(ErrNo.EPERM, "String_Node_Str");
        faMan.checkPrivilegedPermissions(sMan, file, rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        Replica newRepl = rqArgs.getNew_replica();
        org.xtreemfs.interfaces.StripingPolicy sp = newRepl.getStriping_policy();
        StringSet osds = newRepl.getOsd_uuids();
        StripingPolicy sPol = sMan.createStripingPolicy(Converter.intToPolicyName(sp.getPolicy()), sp.getStripe_size(), sp.getWidth());
        if (!file.isReadOnly())
            throw new UserException(ErrNo.EPERM, "String_Node_Str");
        XLocList xLocList = file.getXLocList();
        if (!MRCHelper.isAddable(xLocList, newRepl.getOsd_uuids()))
            throw new UserException("String_Node_Str" + Converter.xLocListToXLocSet(xLocList).toString() + "String_Node_Str");
        XLoc replica = sMan.createXLoc(sPol, osds.toArray(new String[osds.size()]));
        if (xLocList == null)
            xLocList = sMan.createXLocList(new XLoc[] { replica }, 1);
        else {
            XLoc[] repls = new XLoc[xLocList.getReplicaCount() + 1];
            for (int i = 0; i < xLocList.getReplicaCount(); i++) repls[i] = xLocList.getReplica(i);
            repls[repls.length - 1] = replica;
            xLocList = sMan.createXLocList(repls, xLocList.getVersion() + 1);
        }
        file.setXLocList(xLocList);
        AtomicDBUpdate update = sMan.createAtomicDBUpdate(master, rq);
        sMan.setMetadata(file, FileMetadata.XLOC_METADATA, update);
        rq.setResponse(new xtreemfs_replica_addResponse());
        update.execute();
    } catch (UserException exc) {
        Logging.logMessage(Logging.LEVEL_TRACE, this, exc);
        finishRequest(rq, new ErrorRecord(ErrorClass.USER_EXCEPTION, exc.getErrno(), exc.getMessage(), exc));
    } catch (Exception exc) {
        finishRequest(rq, new ErrorRecord(ErrorClass.INTERNAL_SERVER_ERROR, "String_Node_Str", exc));
    }
}

Output:
         finishRequest(rq, new ErrorRecord(ErrorClass.USER_EXCEPTION, exc.getErrno(), exc.getMessage(), exc));
-    } catch (Exception exc) {
+    } catch (Throwable exc) {
         finishRequest(rq, new ErrorRecord(ErrorClass.INTERNAL_SERVER_ERROR, "String_Node_Str", exc));


Input:
public String getRpt(String oxdId, boolean forceNew) {
    SiteConfiguration site = siteService.getSite(oxdId);
    UmaConfiguration discovery = discoveryService.getUmaDiscoveryByOxdId(oxdId);
    if (!forceNew && !Strings.isNullOrEmpty(site.getRpt()) && site.getRptExpiresAt() != null) {
        boolean isExpired = site.getRptExpiresAt().after(new Date());
        if (!isExpired) {
            LOG.debug("String_Node_Str" + site.getRpt() + "String_Node_Str" + site);
            return site.getRpt();
        }
    }
    final CreateRptService rptService = UmaClientFactory.instance().createRequesterPermissionTokenService(discovery, httpService.getClientExecutor());
    final String aat = getAat(oxdId).getToken();
    final RPTResponse rptResponse = rptService.createRPT("String_Node_Str" + aat, site.opHostWithoutProtocol());
    if (rptResponse != null && StringUtils.isNotBlank(rptResponse.getRpt())) {
        RptStatusService rptStatusService = UmaClientFactory.instance().createRptStatusService(discovery, httpService.getClientExecutor());
        RptIntrospectionResponse status = rptStatusService.requestRptStatus("String_Node_Str" + getPat(oxdId).getToken(), rptResponse.getRpt(), "String_Node_Str");
        LOG.debug("String_Node_Str" + rptResponse.getRpt() + "String_Node_Str" + status);
        if (status.getActive()) {
            LOG.debug("String_Node_Str", rptResponse.getRpt());
            site.setRpt(rptResponse.getRpt());
            site.setRptCreatedAt(status.getIssuedAt());
            site.setRptExpiresAt(status.getExpiresAt());
            siteService.updateSilently(site);
            return rptResponse.getRpt();
        }
    }
    LOG.error("String_Node_Str" + site);
    throw new ErrorResponseException(ErrorResponseCode.FAILED_TO_GET_RPT);
}

Output:
     if (!forceNew && !Strings.isNullOrEmpty(site.getRpt()) && site.getRptExpiresAt() != null) {
-        boolean isExpired = site.getRptExpiresAt().after(new Date());
+        boolean isExpired = site.getRptExpiresAt().before(new Date());
         if (!isExpired) {


Input:
public static String urlToHost(String url) {
    String lcUrl = url.toLowerCase();
    if (lcUrl.startsWith("String_Node_Str")) {
        return lcUrl.substring(4);
    }
    for (String scheme : ALL_SCHEMES) {
        if (lcUrl.startsWith(scheme)) {
            int authorityIdx = scheme.length();
            Matcher m = HOST_REGEX_SIMPLE.matcher(lcUrl.substring(authorityIdx));
            if (m.find()) {
                return m.group(1);
            }
        }
    }
    return url;
}

Output:
     String lcUrl = url.toLowerCase();
-    if (lcUrl.startsWith("String_Node_Str")) {
-        return lcUrl.substring(4);
+    if (lcUrl.startsWith(DNS_SCHEME)) {
+        return lcUrl.substring(DNS_SCHEME.length());
     }


Input:
public WifiPasspointInfo createFromParcel(Parcel in) {
    WifiPasspointInfo p = new WifiPasspointInfo();
    int n;
    p.bssid = in.readString();
    p.venueName = in.readString();
    n = in.readInt();
    if (n > 0) {
        p.networkAuthType = new ArrayList<NetworkAuthType>();
        for (int i = 0; i < n; i++) {
            NetworkAuthType auth = new NetworkAuthType();
            auth.type = in.readInt();
            auth.redirectUrl = in.readString();
            p.networkAuthType.add(auth);
        }
    }
    n = in.readInt();
    if (n > 0) {
        p.roamingConsortium = new ArrayList<String>();
        for (int i = 0; i < n; i++) p.roamingConsortium.add(in.readString());
    }
    n = in.readInt();
    if (n != IpAddressType.NULL_VALUE) {
        p.ipAddrTypeAvailability = new IpAddressType();
        p.ipAddrTypeAvailability.availability = n;
    }
    n = in.readInt();
    if (n > 0) {
        p.naiRealm = new ArrayList<NaiRealm>();
        for (int i = 0; i < n; i++) {
            NaiRealm realm = new NaiRealm();
            realm.encoding = in.readInt();
            realm.realm = in.readString();
            p.naiRealm.add(realm);
        }
    }
    n = in.readInt();
    if (n > 0) {
        p.cellularNetwork = new ArrayList<CellularNetwork>();
        for (int i = 0; i < n; i++) {
            CellularNetwork plmn = new CellularNetwork();
            plmn.mcc = in.readString();
            plmn.mnc = in.readString();
            p.cellularNetwork.add(plmn);
        }
    }
    n = in.readInt();
    if (n > 0) {
        p.domainName = new ArrayList<String>();
        for (int i = 0; i < n; i++) p.domainName.add(in.readString());
    }
    p.operatorFriendlyName = in.readString();
    n = in.readInt();
    if (n > 0) {
        p.wanMetrics = new WanMetrics();
        p.wanMetrics.wanInfo = in.readInt();
        p.wanMetrics.downlinkSpeed = in.readLong();
        p.wanMetrics.uplinkSpeed = in.readLong();
        p.wanMetrics.downlinkLoad = in.readInt();
        p.wanMetrics.uplinkLoad = in.readInt();
        p.wanMetrics.lmd = in.readInt();
    }
    n = in.readInt();
    if (n > 0) {
        p.connectionCapability = new ArrayList<IpProtoPort>();
        for (int i = 0; i < n; i++) {
            IpProtoPort ip = new IpProtoPort();
            ip.proto = in.readInt();
            ip.port = in.readInt();
            ip.status = in.readInt();
            p.connectionCapability.add(ip);
        }
    }
    n = in.readInt();
    if (n > 0) {
        p.osuProviderList = new ArrayList<WifiPasspointOsuProvider>();
        for (int i = 0; i < n; i++) {
            WifiPasspointOsuProvider osu = WifiPasspointOsuProvider.CREATOR.createFromParcel(in);
            p.osuProviderList.add(osu);
        }
    }
    return p;
}

Output:
     if (n > 0) {
-        p.networkAuthType = new ArrayList<NetworkAuthType>();
+        p.networkAuthTypeList = new ArrayList<NetworkAuthType>();
         for (int i = 0; i < n; i++) {


Input:
private void copyAttributes(Artifact artifact, Collection<IAttributeType> excudeAttributeTypes) throws OseeCoreException {
    for (Attribute<?> attribute : getAttributes()) {
        if (!excudeAttributeTypes.contains(attribute) && isCopyAllowed(attribute) && artifact.isAttributeTypeValid(attribute.getAttributeType())) {
            artifact.addAttribute(attribute.getAttributeType(), attribute.getValue());
        }
    }
}

Output:
     for (Attribute<?> attribute : getAttributes()) {
-        if (!excudeAttributeTypes.contains(attribute) && isCopyAllowed(attribute) && artifact.isAttributeTypeValid(attribute.getAttributeType())) {
+        if (!excudeAttributeTypes.contains(attribute.getAttributeType()) && isCopyAllowed(attribute) && artifact.isAttributeTypeValid(attribute.getAttributeType())) {
             artifact.addAttribute(attribute.getAttributeType(), attribute.getValue());


Input:
public void update(Observable o, Object arg) {
    int selection = -1;
    CFUnitTestCase tc = (CFUnitTestCase) o;
    clearDetails();
    CFUnitTestResult[] results = tc.getResults();
    String[] list = new String[results.length];
    if (results != null) {
        for (int i = 0; i < results.length; i++) {
            String state;
            switch(results[i].getType()) {
                case CFUnitTestResult.SUCCESS:
                    state = "String_Node_Str";
                    break;
                case CFUnitTestResult.ERROR:
                    state = "String_Node_Str";
                    if (selection == -1)
                        selection = i;
                    break;
                case CFUnitTestResult.FAILURE:
                    state = "String_Node_Str";
                    if (selection == -1)
                        selection = i;
                    break;
                case CFUnitTestResult.NWERROR:
                    state = "String_Node_Str";
                    if (selection == -1)
                        selection = i;
                    break;
                default:
                    state = "String_Node_Str";
                    if (selection == -1)
                        selection = i;
            }
            list[i] = results[i].getName() + "String_Node_Str" + state;
        }
    }
    tests.setItems(list);
    tests.select(selection);
    handleSelection();
}

Output:
             String state;
-            switch(results[i].getType()) {
-                case CFUnitTestResult.SUCCESS:
-                    state = "String_Node_Str";
-                    break;
-                case CFUnitTestResult.ERROR:
-                    state = "String_Node_Str";
-                    if (selection == -1)
-                        selection = i;
-                    break;
-                case CFUnitTestResult.FAILURE:
-                    state = "String_Node_Str";
-                    if (selection == -1)
-                        selection = i;
-                    break;
-                case CFUnitTestResult.NWERROR:
-                    state = "String_Node_Str";
-                    if (selection == -1)
-                        selection = i;
-                    break;
-                default:
-                    state = "String_Node_Str";
-                    if (selection == -1)
-                        selection = i;
+            if (results[i] != null) {
+                switch(results[i].getType()) {
+                    case CFUnitTestResult.SUCCESS:
+                        state = "String_Node_Str";
+                        break;
+                    case CFUnitTestResult.ERROR:
+                        state = "String_Node_Str";
+                        if (selection == -1)
+                            selection = i;
+                        break;
+                    case CFUnitTestResult.FAILURE:
+                        state = "String_Node_Str";
+                        if (selection == -1)
+                            selection = i;
+                        break;
+                    case CFUnitTestResult.NWERROR:
+                        state = "String_Node_Str";
+                        if (selection == -1)
+                            selection = i;
+                        break;
+                    default:
+                        state = "String_Node_Str";
+                        if (selection == -1)
+                            selection = i;
+                }
+                list[i] = results[i].getName() + "String_Node_Str" + state;
             }


Input:
protected Object put(Page p, long writeVersion, Object key, Object value) {
    int index = p.binarySearch(key);
    if (p.isLeaf()) {
        if (index < 0) {
            index = -index - 1;
            p.insertLeaf(index, key, value);
            return null;
        }
        return p.setValue(index, value);
    }
    if (index < 0) {
        index = -index - 1;
    } else {
        index++;
    }
    Page c = copyOnWrite(p.getChildPage(index), writeVersion, true);
    if (c.getMemory() > store.getPageSplitSize() && c.getKeyCount() > 1) {
        int at = c.getKeyCount() / 2;
        Object k = c.getKey(at);
        Page split = c.split(at);
        p.setChild(index, split);
        p.setCounts(index, split);
        p.insertNode(index, k, c);
        return put(p, writeVersion, key, value);
    }
    p.setChild(index, c);
    Object result = put(c, writeVersion, key, value);
    p.setCounts(index, c);
    return result;
}

Output:
     }
-    Page c = copyOnWrite(p.getChildPage(index), writeVersion, true);
+    Page c = copyOnWrite(p.getChildPage(index), writeVersion);
     if (c.getMemory() > store.getPageSplitSize() && c.getKeyCount() > 1) {


Input:
private String generateOptionalSafeTagsArg(List<? extends TargetExpr> args) {
    String optionalSafeTagsArg = "String_Node_Str";
    if (!args.isEmpty()) {
        Iterable<String> optionalSafeTagExprs = Iterables.transform(args, TARGET_EXPR_TO_STRING);
        FluentIterable.from(optionalSafeTagExprs).transform(SINGLE_QUOTED_TO_UNQUOTED).transform(OptionalSafeTag.FROM_TAG_NAME).toSet();
        optionalSafeTagsArg = "String_Node_Str" + ARG_JOINER.join(optionalSafeTagExprs) + "String_Node_Str";
    }
    return optionalSafeTagsArg;
}

Output:
         Iterable<String> optionalSafeTagExprs = Iterables.transform(args, TARGET_EXPR_TO_STRING);
-        FluentIterable.from(optionalSafeTagExprs).transform(SINGLE_QUOTED_TO_UNQUOTED).transform(OptionalSafeTag.FROM_TAG_NAME).toSet();
+        for (String singleQuoted : optionalSafeTagExprs) {
+            if (singleQuoted.length() < 2 || singleQuoted.charAt(0) != '\'' || singleQuoted.charAt(singleQuoted.length() - 1) != '\'') {
+                throw new IllegalArgumentException(String.format("String_Node_Str" + "String_Node_Str", singleQuoted));
+            }
+            String tagName = singleQuoted.substring(1, singleQuoted.length() - 1);
+            OptionalSafeTag.fromTagName(tagName);
+        }
         optionalSafeTagsArg = "String_Node_Str" + ARG_JOINER.join(optionalSafeTagExprs) + "String_Node_Str";


Input:
public void cancelNotification() {
    if (foregroundId != 0) {
        final String localPackageName = packageName;
        final int localForegroundId = foregroundId;
        ams.mHandler.post(new Runnable() {

            public void run() {
                INotificationManager inm = NotificationManager.getService();
                if (inm == null) {
                    return;
                }
                try {
                    inm.cancelNotificationWithTag(localPackageName, null, localForegroundId, userId);
                } catch (RuntimeException e) {
                    Slog.w(TAG, "String_Node_Str", e);
                } catch (RemoteException e) {
                }
            }
        });
    }
}

Output:
 public void cancelNotification() {
-    if (foregroundId != 0) {
-        final String localPackageName = packageName;
-        final int localForegroundId = foregroundId;
-        ams.mHandler.post(new Runnable() {
+    final String localPackageName = packageName;
+    final int localForegroundId = foregroundId;
+    ams.mHandler.post(new Runnable() {


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    MageObject sourceObject = game.getObject(source.getSourceId());
    if (controller != null && sourceObject != null) {
        if (!controller.getHand().isEmpty()) {
            Card cardToReveal = null;
            if (controller.getHand().size() > 1) {
                Target target = new TargetCardInHand(new FilterCard());
                target.setNotTarget(true);
                if (controller.chooseTarget(outcome, target, source, game)) {
                    cardToReveal = game.getCard(target.getFirstTarget());
                }
            } else {
                cardToReveal = controller.getHand().getRandom(game);
            }
            FilterCard filterCard;
            if (cardToReveal != null) {
                controller.revealCards("String_Node_Str" + sourceObject.getName(), new CardsImpl(cardToReveal), game);
                filterCard = new FilterCard("String_Node_Str" + cardToReveal.getName());
                filterCard.add(new NamePredicate(cardToReveal.getName()));
            } else {
                filterCard = new FilterCard();
            }
            return new SearchLibraryPutInHandEffect(new TargetCardInLibrary(filterCard), true, true).apply(game, source);
        }
        return true;
    }
    return false;
}

Output:
                 controller.revealCards("String_Node_Str" + sourceObject.getName(), new CardsImpl(cardToReveal), game);
-                filterCard = new FilterCard("String_Node_Str" + cardToReveal.getName());
-                filterCard.add(new NamePredicate(cardToReveal.getName()));
+                String nameToSearch = cardToReveal.isSplitCard() ? ((SplitCard) cardToReveal).getLeftHalfCard().getName() : cardToReveal.getName();
+                filterCard = new FilterCard("String_Node_Str" + nameToSearch);
+                filterCard.add(new NamePredicate(nameToSearch));
             } else {


Input:
protected ValidationRuleExcpressDialog getExpressDialog() {
    return new ValidationRuleExcpressDialog(page.getSite().getShell(), getTreeParent(), Messages.getMessage("String_Node_Str"), struc.getDefaultValueRule(), conceptName, false, false);
}

Output:
 protected ValidationRuleExcpressDialog getExpressDialog() {
-    return new ValidationRuleExcpressDialog(page.getSite().getShell(), getTreeParent(), Messages.getMessage("String_Node_Str"), struc.getDefaultValueRule(), conceptName, false, false);
+    return new ValidationRuleExcpressDialog(page.getSite().getShell(), getTreeParent(), Messages.getString("String_Node_Str"), struc.getDefaultValueRule(), conceptName, false, false);
 }


Input:
public boolean isSimilar(EObject obj1, EObject obj2) throws FactoryException {
    DatabaseConnection connection1 = SwitchHelpers.DATABASECONNECTION_SWITCH.doSwitch(obj1);
    DatabaseConnection connection2 = SwitchHelpers.DATABASECONNECTION_SWITCH.doSwitch(obj2);
    if (connection1 != null && connection2 != null) {
        changeUrl = ConnectionHelper.isUrlChanged(connection1);
    }
    return changeUrl ? false : super.isSimilar(obj1, obj2);
}

Output:
 public boolean isSimilar(EObject obj1, EObject obj2) throws FactoryException {
-    DatabaseConnection connection1 = SwitchHelpers.DATABASECONNECTION_SWITCH.doSwitch(obj1);
-    DatabaseConnection connection2 = SwitchHelpers.DATABASECONNECTION_SWITCH.doSwitch(obj2);
-    if (connection1 != null && connection2 != null) {
-        changeUrl = ConnectionHelper.isUrlChanged(connection1);
-    }
-    return changeUrl ? false : super.isSimilar(obj1, obj2);
+    return Boolean.TRUE;
 }


Input:
public void bindData(BlogPost post) {
    this.post = post;
    bind.nickname.setText(post.getOwner_name());
    bind.content.setText(UtilsManager.cut(post.getContent(), 500));
    bind.date.setText(post.getDate());
    bind.like.setText(context.getResources().getString(R.string.like_cnt, post.getLike()));
    bind.comment.setText(context.getResources().getString(R.string.comment_cnt, post.getComment()));
    bind.view.setText(context.getResources().getString(R.string.view_cnt, post.getView()));
    if (post.getOwner_photo_url() != null)
        Picasso.with(context).load(post.getOwner_photo_url()).into(bind.photo);
}

Output:
     if (post.getOwner_photo_url() != null)
-        Picasso.with(context).load(post.getOwner_photo_url()).into(bind.photo);
+        Picasso.with(context).load(post.getOwner_photo_url()).resize(ImageUtils.SIZE_L, ImageUtils.SIZE_L).into(bind.photo);
 }


Input:
public boolean onMessage(int src, int destination, int target, int flags, Object object) {
    this.source = src;
    List<Object> dests = destinationMessages.get(destination);
    int size = dests.size();
    if (size > highWaterMark) {
        return false;
    }
    lock.lock();
    try {
        dests.add(object);
        if (dests.size() > lowWaterMark) {
            swapToReady(destination, dests);
        }
    } finally {
        lock.unlock();
    }
    return true;
}

Output:
 public boolean onMessage(int src, int destination, int target, int flags, Object object) {
-    this.source = src;
+    this.representSource = src;
     List<Object> dests = destinationMessages.get(destination);


Input:
public static void createLoot() {
    cocoonSilk.getCocoonLoot().put(PluginCore.items.craftingMaterial.getSilkWisp(), 0.75F);
    cocoonSilk.getCocoonLoot().put(PluginCore.items.craftingMaterial.getSilkWisp(), 0.25F);
}

Output:
 public static void createLoot() {
-    cocoonSilk.getCocoonLoot().put(PluginCore.items.craftingMaterial.getSilkWisp(), 0.75F);
-    cocoonSilk.getCocoonLoot().put(PluginCore.items.craftingMaterial.getSilkWisp(), 0.25F);
+    cocoonDefault.getCocoonLoot().put(new ItemStack(Items.STRING, 2), 1F);
+    cocoonDefault.getCocoonLoot().put(new ItemStack(Items.STRING), 0.75F);
+    cocoonDefault.getCocoonLoot().put(new ItemStack(Items.STRING, 3), 0.25F);
+    cocoonSilk.getCocoonLoot().put(new ItemStack(PluginCore.items.craftingMaterial, 3, 2), 0.75F);
+    cocoonSilk.getCocoonLoot().put(new ItemStack(PluginCore.items.craftingMaterial, 2, 2), 0.25F);
 }


Input:
private void initBuf() {
    writeBuf = ByteBuffer.allocate(RpcUtils.MEM_2M);
    readBuf = ByteBuffer.allocate(RpcUtils.MEM_2M);
}

Output:
 private void initBuf() {
-    writeBuf = ByteBuffer.allocate(RpcUtils.MEM_2M);
-    readBuf = ByteBuffer.allocate(RpcUtils.MEM_2M);
+    channelWriteBuffer = ByteBuffer.allocate(RpcUtils.MEM_2M);
+    channelReadBuffer = ByteBuffer.allocate(RpcUtils.MEM_2M);
+    rpcNioReadBuffer = new RpcNioBuffer(RpcUtils.MEM_2M);
+    rpcNioWriteBuffer = new RpcNioBuffer(RpcUtils.MEM_2M);
 }


Input:
public void widgetSelected(final SelectionEvent arg0) {
    if (filter != null) {
        filter.allowInformationLoss(intToInformationLoss(min.getSelection()), filter.getAllowedMaxInformationLoss());
        controller.update(new ModelEvent(outer, ModelPart.FILTER, filter));
    }
}

Output:
     if (filter != null) {
-        filter.allowInformationLoss(intToInformationLoss(min.getSelection()), filter.getAllowedMaxInformationLoss());
+        double minLoss = intToInformationLoss(min.getSelection());
+        double maxLoss = filter.getAllowedMaxInformationLoss();
+        filter.allowInformationLoss(minLoss, maxLoss);
         controller.update(new ModelEvent(outer, ModelPart.FILTER, filter));


Input:
public String toString() {
    String res = opcode + "String_Node_Str" + arg1 + "String_Node_Str" + arg2 + "String_Node_Str" + arg3 + "String_Node_Str";
    if (tag != null) {
        res += "String_Node_Str" + tag;
    }
    return res;
}

Output:
     String res = opcode + "String_Node_Str" + arg1 + "String_Node_Str" + arg2 + "String_Node_Str" + arg3 + "String_Node_Str";
-    if (tag != null) {
+    for (String tag : tags) {
         res += "String_Node_Str" + tag;


Input:
public static DataminingType getDataminingType(ModelElement modelElement) {
    if (modelElement != null) {
        if (modelElement instanceof TdColumn) {
            return getDataminingType((TdColumn) modelElement);
        } else if (modelElement instanceof TdXmlElementType) {
            DataminingType.get(((TdXmlElementType) modelElement).getContentType());
        }
    }
    return getDefaultDataminingType(0);
}

Output:
         } else if (modelElement instanceof TdXmlElementType) {
-            DataminingType.get(((TdXmlElementType) modelElement).getContentType());
+            return DataminingType.get(((TdXmlElementType) modelElement).getContentType());
         }


Input:
public static boolean isPrimitiveLike(final Class type) {
    if (type == null) {
        return false;
    }
    return (type == String.class) || (type == char.class) || (type == Character.class) || (type == short.class) || (type == Short.class) || (type == Integer.class) || (type == int.class) || (type == Long.class) || (type == long.class) || (type == Double.class) || (type == double.class) || (type == float.class) || (type == Float.class) || (type == Boolean.class) || (type == boolean.class) || (type == Byte.class) || (type == byte.class) || (type == Date.class) || (type == Locale.class) || (type == Class.class) || (type == UUID.class) || type.isEnum();
}

Output:
     }
-    return (type == String.class) || (type == char.class) || (type == Character.class) || (type == short.class) || (type == Short.class) || (type == Integer.class) || (type == int.class) || (type == Long.class) || (type == long.class) || (type == Double.class) || (type == double.class) || (type == float.class) || (type == Float.class) || (type == Boolean.class) || (type == boolean.class) || (type == Byte.class) || (type == byte.class) || (type == Date.class) || (type == Locale.class) || (type == Class.class) || (type == UUID.class) || type.isEnum();
+    return (type == String.class) || (type == char.class) || (type == Character.class) || (type == short.class) || (type == Short.class) || (type == Integer.class) || (type == int.class) || (type == Long.class) || (type == long.class) || (type == Double.class) || (type == double.class) || (type == float.class) || (type == Float.class) || (type == Boolean.class) || (type == boolean.class) || (type == Byte.class) || (type == byte.class) || (type == Date.class) || (type == Locale.class) || (type == Class.class) || (type == UUID.class) || (type == URI.class) || type.isEnum();
 }


Input:
public void handleData(T data) {
    super.handleData(data);
    for (ITmfDataRequest<T> request : fRequests) {
        if (data == null) {
            request.handleData(null);
        } else {
            if (request instanceof TmfEventRequest<?>) {
                TmfEventRequest<T> req = (TmfEventRequest<T>) request;
                if (!req.isCompleted() && (getIndex() + getNbRead() > request.getIndex())) {
                    ITmfTimestamp ts = data.getTimestamp();
                    if (req.getRange().contains(ts)) {
                        if (req.getDataType().isInstance(data)) {
                            req.handleData(data);
                        }
                    }
                }
            } else {
                TmfDataRequest<T> req = (TmfDataRequest<T>) request;
                if (!req.isCompleted()) {
                    if (req.getDataType().isInstance(data)) {
                        req.handleData(data);
                    }
                }
            }
        }
    }
}

Output:
                 TmfEventRequest<T> req = (TmfEventRequest<T>) request;
-                if (!req.isCompleted() && (getIndex() + getNbRead() > request.getIndex())) {
+                if (!req.isCompleted() && index >= start && index < end) {
                     ITmfTimestamp ts = data.getTimestamp();


Input:
public void verify_A$String$OAuthConsumer$HttpMethod$SignatureMethod() throws Exception {
    String authorizationHeader = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    OAuthConsumer consumer = new OAuthConsumer("String_Node_Str", "String_Node_Str");
    boolean actual = SignedRequestVerifier.verify("String_Node_Str", authorizationHeader, consumer, HttpMethod.GET, SignatureMethod.HMAC_SHA1);
    boolean expected = true;
    assertEquals(expected, actual);
}

Output:
     OAuthConsumer consumer = new OAuthConsumer("String_Node_Str", "String_Node_Str");
-    boolean actual = SignedRequestVerifier.verify("String_Node_Str", authorizationHeader, consumer, HttpMethod.GET, SignatureMethod.HMAC_SHA1);
+    boolean actual = SignedRequestVerifier.verify("String_Node_Str", "String_Node_Str", authorizationHeader, consumer, HttpMethod.GET, SignatureMethod.HMAC_SHA1);
     boolean expected = true;


Input:
public Connection choose() {
    while (true) {
        Endpoint e = null;
        synchronized (this) {
            while (e == null) {
                if (manager != null && !manager.needsMoreConnections())
                    return null;
                try {
                    e = getAnEndpoint();
                } catch (NoSuchElementException exc) {
                    try {
                        this.wait(2000);
                    } catch (InterruptedException exc2) {
                    }
                }
            }
        }
        if (manager != null && manager.isConnected(e))
            continue;
        Connection ret = null;
        try {
            ret = new Connection(e.hostname, e.port);
            if (manager != null)
                manager.tryingToConnect(ret, false);
            ret.connect();
            return ret;
        } catch (IOException exc) {
            if (manager != null)
                manager.failedToConnect(ret);
            continue;
        }
    }
}

Output:
             ret = new Connection(e.hostname, e.port);
-            if (manager != null)
+            if (manager != null) {
                 manager.tryingToConnect(ret, false);


Input:
protected void onConfigure() {
    super.onConfigure();
    IVisitor<Component, Boolean> visitor = new IVisitor<Component, Boolean>() {
        public void component(Component component, IVisit<Boolean> visit) {
            component.configure();
            if (component.determineVisibility()) {
                visit.stop(true);
            } else {
                visit.dontGoDeeper();
            }
        }
    };
    Boolean ret = commands.visitChildren(visitor);
    if (ret == null || ret == false) {
        ret = methods.visitChildren(visitor);
    }
    setVisible(ret != null ? ret : false);
}

Output:
     Boolean ret = commands.visitChildren(visitor);
-    if (ret == null || ret == false) {
+    if (ret == null || !ret) {
         ret = methods.visitChildren(visitor);


Input:
public String toString() {
    return new ToStringBuilder(this, ToStringStyle.DEFAULT_STYLE).append("String_Node_Str", sources).append("String_Node_Str", channels).toString();
}

Output:
 public String toString() {
-    return new ToStringBuilder(this, ToStringStyle.DEFAULT_STYLE).append("String_Node_Str", sources).append("String_Node_Str", channels).toString();
+    return new ToStringBuilder(this, ToStringStyle.DEFAULT_STYLE).append("String_Node_Str", subscribers.size()).append("String_Node_Str", sources).toString();
 }


Input:
private void openTask(int indent, String name) {
    isTask = true;
    String className = getImport(name);
    if (className == null)
        className = name;
    try {
        Node<E> node = (Node<E>) ClassReflection.newInstance(ClassReflection.forName(className));
        if (prevNode == null) {
            root = node;
            rootIndent = indent;
            indent = 0;
        } else {
            indent -= rootIndent;
            if (prevNode.node == root) {
                step = indent;
            }
            if (indent > currentDepth) {
                stack.add(prevNode);
            } else if (indent < currentDepth) {
                int i = (currentDepth - indent) / step;
                for (int j = 0; j < i; j++) {
                    StackedNode<E> stackedNode = stack.pop();
                    int minChildren = stackedNode.metadata.getMinChildren();
                    if (stackedNode.node.getChildCount() < minChildren)
                        throw new GdxRuntimeException(stackedNode.name + "String_Node_Str" + stackedNode.node.getChildCount() + "String_Node_Str" + minChildren + "String_Node_Str");
                }
            }
            StackedNode<E> stackedParent = stack.peek();
            int maxChildren = stackedParent.metadata.getMaxChildren();
            if (stackedParent.node.getChildCount() >= maxChildren)
                throw new GdxRuntimeException(stackedParent.name + "String_Node_Str" + (stackedParent.node.getChildCount() + 1) + "String_Node_Str" + maxChildren + "String_Node_Str");
            stackedParent.node.addChild(node);
        }
        prevNode = new StackedNode<E>(name, node);
        currentDepth = indent;
    } catch (ReflectionException e) {
        throw new GdxRuntimeException("String_Node_Str", e);
    }
}

Output:
                 stack.add(prevNode);
-            } else if (indent < currentDepth) {
+            } else if (indent <= currentDepth) {
                 int i = (currentDepth - indent) / step;


Input:
public IReportRunnable getReportRunnable() {
    loadMainInfoLazily();
    return getReportRunnable(true, systemId);
}

Output:
     loadMainInfoLazily();
-    return getReportRunnable(true, systemId);
+    if (reportRunnable == null) {
+        reportRunnable = getReportRunnable(true, systemId);
+    }
+    return reportRunnable.cloneRunnable();
 }


Input:
public void addTarget(UUID id, int amount, Ability source, Game game, boolean skipEvent) {
    if (targets.containsKey(id)) {
        amount += targets.get(id);
    }
    if (source != null) {
        if (!skipEvent && !game.replaceEvent(GameEvent.getEvent(EventType.TARGET, id, source.getId(), source.getControllerId()))) {
            targets.put(id, amount);
            rememberZoneChangeCounter(id, game);
            chosen = targets.size() >= minNumberOfTargets;
            if (!skipEvent) {
                game.fireEvent(GameEvent.getEvent(EventType.TARGETED, id, source.getId(), source.getControllerId()));
            }
        }
    } else {
        targets.put(id, amount);
        rememberZoneChangeCounter(id, game);
    }
}

Output:
     }
-    if (source != null) {
-        if (!skipEvent && !game.replaceEvent(GameEvent.getEvent(EventType.TARGET, id, source.getId(), source.getControllerId()))) {
+    if (source != null && !skipEvent) {
+        if (!game.replaceEvent(GameEvent.getEvent(EventType.TARGET, id, source.getId(), source.getControllerId()))) {
             targets.put(id, amount);


Input:
public Future<Bitmap> asBitmap() {
    if (builder.uri == null) {
        return FUTURE_BITMAP_NULL_URI;
    }
    BitmapFetcher bitmapFetcher = executeCache();
    if (bitmapFetcher.info != null) {
        SimpleFuture<Bitmap> ret = new SimpleFuture<Bitmap>();
        Bitmap bitmap = bitmapFetcher.info.bitmaps == null ? null : bitmapFetcher.info.bitmaps[0];
        ret.setComplete(bitmapFetcher.info.exception, bitmap);
        return ret;
    }
    bitmapFetcher.execute();
    BitmapInfoToBitmap ret = new BitmapInfoToBitmap(builder.contextReference);
    ion.bitmapsPending.add(bitmapFetcher.bitmapKey, ret);
    return ret;
}

Output:
     }
-    BitmapFetcher bitmapFetcher = executeCache();
+    final BitmapFetcher bitmapFetcher = executeCache();
     if (bitmapFetcher.info != null) {


Input:
private void createCube(IDocArchiveWriter writter, DataEngine engine) throws BirtException, IOException {
    CubeMaterializer cubeMaterializer = new CubeMaterializer(documentPath + engine.hashCode(), "String_Node_Str");
    IDocumentManager documentManager = cubeMaterializer.getDocumentManager();
    Dimension[] dimensions = new Dimension[2];
    String[] levelNames = new String[3];
    levelNames[0] = "String_Node_Str";
    levelNames[1] = "String_Node_Str";
    levelNames[2] = "String_Node_Str";
    DimensionForTest iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, TestFactTable.DIM0_L1Col);
    iterator.setLevelMember(1, TestFactTable.DIM0_L2Col);
    iterator.setLevelMember(2, TestFactTable.DIM0_L3Col);
    ILevelDefn[] levelDefs = new ILevelDefn[3];
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    levelDefs[1] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    levelDefs[2] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[0] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    IHierarchy hierarchy = dimensions[0].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    assertEquals(dimensions[0].length(), 13);
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(TestFactTable.DIM1_L1Col));
    levelDefs = new ILevelDefn[1];
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[1] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    hierarchy = dimensions[1].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    assertEquals(dimensions[1].length(), 5);
    TestFactTable factTable2 = new TestFactTable();
    String[] measureColumnName = new String[1];
    measureColumnName[0] = "String_Node_Str";
    Cube cube = new Cube(cubeName, documentManager);
    cube.create(CubeUtility.getKeyColNames(dimensions), dimensions, factTable2, measureColumnName, new StopSign());
    cube.close();
    documentManager.flush();
    cubeMaterializer.saveCubeToReportDocument("String_Node_Str", writter, null);
    cubeMaterializer.close();
}

Output:
 private void createCube(IDocArchiveWriter writter, DataEngine engine) throws BirtException, IOException {
-    CubeMaterializer cubeMaterializer = new CubeMaterializer(documentPath + engine.hashCode(), "String_Node_Str");
+    CubeMaterializer cubeMaterializer = new CubeMaterializer(engine, documentPath + engine.hashCode(), "String_Node_Str");
     IDocumentManager documentManager = cubeMaterializer.getDocumentManager();


Input:
public boolean apply(Game game, Ability source) {
    Permanent permanent = game.getPermanentEntering(source.getSourceId());
    SubType subtype = (SubType) game.getState().getValue(source.getSourceId() + "String_Node_Str");
    if (permanent != null && subtype != null) {
        MageObject mageObject = permanent.getBasicMageObject(game);
        if (!mageObject.getSubtype(null).contains(subtype)) {
            mageObject.getSubtype(null).add(subtype);
        }
        if (!permanent.getSubtype(null).contains(subtype)) {
            permanent.getSubtype(null).add(subtype);
        }
        return true;
    }
    return false;
}

Output:
     if (permanent != null && subtype != null) {
-        MageObject mageObject = permanent.getBasicMageObject(game);
-        if (!mageObject.getSubtype(null).contains(subtype)) {
-            mageObject.getSubtype(null).add(subtype);
-        }
-        if (!permanent.getSubtype(null).contains(subtype)) {
-            permanent.getSubtype(null).add(subtype);
+        if (!permanent.getSubtype(game).contains(subtype)) {
+            permanent.getSubtype(game).add(subtype);
         }


Input:
private void processDate(final String line) {
    if (line.startsWith("String_Node_Str")) {
        m_date = line.substring(6, 16);
        String lineData = line.substring(line.indexOf("String_Node_Str") + 1);
        m_author = lineData.substring(10, lineData.indexOf("String_Node_Str"));
        if (m_userList.containsKey(m_author)) {
            m_author = "String_Node_Str" + m_userList.getProperty(m_author) + "String_Node_Str";
        }
        m_status = GET_COMMENT;
        m_comment = "String_Node_Str";
    }
}

Output:
         if (m_userList.containsKey(m_author)) {
-            m_author = "String_Node_Str" + m_userList.getProperty(m_author) + "String_Node_Str";
+            m_author = m_userList.getProperty(m_author);
         }


Input:
public void run() {
    try {
        log.info("String_Node_Str" + peer);
        peer.connect();
        peers.add(peer);
        handleNewPeer(peer);
        log.info("String_Node_Str" + peer);
        peer.run();
    } catch (RuntimeException ex) {
        log.error("String_Node_Str", ex);
    } finally {
        try {
            peer.disconnect();
        } catch (RuntimeException ex) {
        }
        inactives.add(address);
        if (peers.remove(peer))
            handlePeerDeath(peer);
    }
}

Output:
         peer.run();
-    } catch (RuntimeException ex) {
+    } catch (PeerException ex) {
         log.error("String_Node_Str", ex);


Input:
public void getImageAsync(PlayableItem item, ImageView imageView) {
    Bitmap image = null;
    synchronized (cache) {
        image = cache.get(item.getPlayableUri());
    }
    if (image == null) {
        ImageLoaderTask imageLoader = new ImageLoaderTask(item, imageView);
        imageLoader.execute();
    } else {
        imageView.setImageBitmap(image);
        imageView.setVisibility(View.VISIBLE);
    }
}

Output:
 public void getImageAsync(PlayableItem item, ImageView imageView) {
-    Bitmap image = null;
+    Bitmap image;
     synchronized (cache) {


Input:
public static File createEntityFile(Class<?> clazz, ContentType contentType, Collection nodes, JsonBlobType jsonBlobType) throws IOException {
    File file = File.createTempFile(clazz.getSimpleName() + "String_Node_Str" + contentType.getMimeType().replace('/', '-') + "String_Node_Str", null);
    file.deleteOnExit();
    String arrayName = "String_Node_Str";
    if (jsonBlobType == JsonBlobType.PROJECT) {
        arrayName = "String_Node_Str";
    } else if (jsonBlobType == JsonBlobType.REF) {
        arrayName = "String_Node_Str";
    }
    try (FileOutputStream outputStream = new FileOutputStream(file);
        JsonGenerator jsonGenerator = JacksonUtils.getJsonFactory().createGenerator(outputStream)) {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeArrayFieldStart(arrayName);
        for (Object node : nodes) {
            if (node instanceof ObjectNode && jsonBlobType == JsonBlobType.ELEMENT_JSON || jsonBlobType == JsonBlobType.ORG || jsonBlobType == JsonBlobType.PROJECT || jsonBlobType == JsonBlobType.REF) {
                jsonGenerator.writeObject(node);
            } else if (node instanceof String && jsonBlobType == JsonBlobType.ELEMENT_ID) {
                jsonGenerator.writeStartObject();
                jsonGenerator.writeStringField(MDKConstants.ID_KEY, (String) node);
                jsonGenerator.writeEndObject();
            } else {
                throw new IOException("String_Node_Str");
            }
        }
        jsonGenerator.writeEndArray();
        jsonGenerator.writeStringField("String_Node_Str", "String_Node_Str");
        jsonGenerator.writeStringField("String_Node_Str", MDKPlugin.VERSION);
        jsonGenerator.writeEndObject();
    }
    System.out.println(file.getPath());
    return file;
}

Output:
     }
-    System.out.println(file.getPath());
+    System.out.println("String_Node_Str" + file.getPath());
     return file;


Input:
public String randomValueForSetter() throws XDocletException {
    Properties pros = new Properties();
    pros.put("String_Node_Str", "String_Node_Str");
    String mtype = super.methodType(pros);
    StringBuffer result = new StringBuffer();
    if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (int) ((Math.random() * Integer.MAX_VALUE)) + "String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (int) ((Math.random() * Integer.MAX_VALUE)));
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (float) ((Math.random() * Float.MAX_VALUE)) + "String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (float) ((Math.random() * Float.MAX_VALUE)));
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (long) ((Math.random() * Integer.MAX_VALUE)) + "String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append((long) ((Math.random() * Integer.MAX_VALUE)));
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (double) ((Math.random() * Double.MAX_VALUE)) + "String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append((double) ((Math.random() * Double.MAX_VALUE)));
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (short) ((Math.random() * Short.MAX_VALUE)) + "String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (short) ((Math.random() * Short.MAX_VALUE)));
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (byte) ((Math.random() * Byte.MAX_VALUE)) + "String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + (byte) ((Math.random() * Byte.MAX_VALUE)));
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + getDate(new Date()) + "String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append("String_Node_Str" + new Timestamp(new Date().getTime()).toString() + "String_Node_Str");
    } else if ("String_Node_Str".equalsIgnoreCase(super.propertyName())) {
        result.append("String_Node_Str" + super.propertyName() + (int) ((Math.random() * Integer.MAX_VALUE)) + "String_Node_Str");
    } else if ("String_Node_Str".equals(mtype)) {
        result.append(generateStringValue());
    } else {
        throw new XDocletException("String_Node_Str" + mtype);
    }
    return result.toString();
}

Output:
     } else {
-        throw new XDocletException("String_Node_Str" + mtype);
+        result.append(generateStringValue());
     }


Input:
private void updateFieldIndices() {
    final ZooPC[] buffer = this.buffer;
    final int bufferCnt = this.bufferCnt;
    int iInd = -1;
    int iField = -1;
    for (ZooFieldDef field : cls.getAllFields()) {
        iField++;
        if (!field.isIndexed()) {
            continue;
        }
        iInd++;
        SchemaIndexEntry schemaTop = node.getSchemaIE(field.getDeclaringType());
        LongLongIndex fieldInd = (LongLongIndex) schemaTop.getIndex(field);
        try {
            Field jField = field.getJavaField();
            for (int i = 0; i < bufferCnt; i++) {
                ZooPC co = buffer[i];
                final long l;
                if (field.isString()) {
                    String str = (String) jField.get(co);
                    l = BitTools.toSortableLong(str);
                } else {
                    l = SerializerTools.primitiveFieldToLong(co, jField, field.getPrimitiveType());
                }
                if (!co.jdoZooIsNew()) {
                    long lOld = co.jdoZooGetBackup()[iInd];
                    if (lOld == l) {
                        continue;
                    }
                    fieldInd.removeLong(lOld, co.jdoZooGetOid());
                }
                if (field.isIndexUnique()) {
                    if (!fieldInd.insertLongIfNotSet(l, co.jdoZooGetOid())) {
                        if (fieldUpdateBuffer[iField] == null) {
                            fieldUpdateBuffer[iField] = new ArrayList<Pair>();
                        }
                        fieldUpdateBuffer[iField].add(new Pair(co.jdoZooGetOid(), l));
                    }
                } else {
                    fieldInd.insertLong(l, co.jdoZooGetOid());
                }
            }
        } catch (SecurityException e) {
            throw DBLogger.newFatal("String_Node_Str" + field.getName(), e);
        } catch (IllegalArgumentException e) {
            throw DBLogger.newFatal("String_Node_Str" + field.getName(), e);
        } catch (IllegalAccessException e) {
            throw DBLogger.newFatal("String_Node_Str" + field.getName(), e);
        }
    }
}

Output:
                 if (field.isString()) {
-                    String str = (String) jField.get(co);
+                    str = (String) jField.get(co);
                     l = BitTools.toSortableLong(str);


Input:
public void run() {
    PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().saveAllEditors(true);
    Set<IRepositoryViewObject> allChangedObjects = findAllChangedObjects();
    String name = getSameServerName();
    allChangedObjects.addAll(RemoveFromRepositoryAction.getViewObjectsRemovedList());
    DeployAllDialog dialog = new DeployAllDialog(getShell(), commonViewer.getInput(), allChangedObjects, name);
    int retCode = dialog.open();
    IS_DEPLOYALL_FLAG = false;
    IRepositoryViewObject[] theInput = (IRepositoryViewObject[]) commonViewer.getInput();
    backDeleteObjectsTreeView(theInput);
    if (retCode == IDialogConstants.OK_ID) {
        List<IRepositoryViewObject> selectededViewObjs = dialog.getSelectededViewObjs();
        for (IRepositoryViewObject viewObj : selectededViewObjs) {
            Item item = viewObj.getProperty().getItem();
            MDMServerObject serverObj = ((MDMServerObjectItem) item).getMDMServerObject();
            serverObj.getLastServerDef();
        }
        MDMServerDef def = dialog.getTheServerDef();
        List<IRepositoryViewObject> viewObjectsRemoved = new ArrayList<IRepositoryViewObject>();
        for (IRepositoryViewObject viewObj : selectededViewObjs) {
            if (RemoveFromRepositoryAction.getViewObjectsRemovedList().contains(viewObj)) {
                viewObjectsRemoved.add(viewObj);
            }
        }
        for (IRepositoryViewObject viewObj : viewObjectsRemoved) {
            selectededViewObjs.remove(viewObj);
        }
        if (selectededViewObjs.size() >= 0) {
            IStatus status = updateServer(def, selectededViewObjs, viewObjectsRemoved);
            updateChangedStatus(status);
            if (status.isMultiStatus()) {
                showDeployStatus(status);
            }
            if (status.isMultiStatus()) {
                for (IStatus childStatus : status.getChildren()) {
                    DeployService.DeployStatus deployStatus = (DeployStatus) childStatus;
                    if (deployStatus.isOK()) {
                        if (deployStatus.getItem() instanceof MDMServerObjectItem)
                            saveLastServer((MDMServerObjectItem) deployStatus.getItem(), def, selectededViewObjs);
                    }
                }
            }
        }
    }
    defNames.clear();
}

Output:
     if (retCode == IDialogConstants.OK_ID) {
-        List<IRepositoryViewObject> selectededViewObjs = dialog.getSelectededViewObjs();
+        selectededViewObjs = dialog.getSelectededViewObjs();
         for (IRepositoryViewObject viewObj : selectededViewObjs) {


Input:
protected void setSdnvFromTime(Time time) {
    long newValue = dtnUtil.DateToDtnShortDate(new Date(time.toMillis(false)));
    sdnv.setByValue(newValue);
    update(Type.DATE);
    updateDatesFromNumbers();
}

Output:
     long newValue = dtnUtil.DateToDtnShortDate(new Date(time.toMillis(false)));
-    sdnv.setByValue(newValue);
+    try {
+        sdnv.setByValue(newValue);
+    } catch (NumberFormatException e) {
+    }
     update(Type.DATE);


Input:
public View getView(int position, View convertView, ViewGroup parent) {
    int numHeadersAndPlaceholders = getHeadersCount() * mNumColumns;
    if (position < numHeadersAndPlaceholders) {
        View headerViewContainer = mHeaderViewInfos.get(position / mNumColumns).viewContainer;
        if (position % mNumColumns == 0) {
            return headerViewContainer;
        } else {
            convertView = new View(parent.getContext());
            convertView.setVisibility(View.INVISIBLE);
            convertView.setMinimumHeight(headerViewContainer.getHeight());
            return convertView;
        }
    }
    if (position < numHeadersAndPlaceholders + mAdapter.getCount()) {
        final int adjPosition = position - numHeadersAndPlaceholders;
        int adapterCount = 0;
        if (mAdapter != null) {
            adapterCount = mAdapter.getCount();
            if (adjPosition < adapterCount) {
                return mAdapter.getView(adjPosition, convertView, parent);
            }
        }
    }
    final int lastRowItemCount = (mAdapter.getCount() % mNumColumns);
    final int emptyItemCount = ((lastRowItemCount == 0) ? 0 : mNumColumns - lastRowItemCount);
    if (position < numHeadersAndPlaceholders + mAdapter.getCount() + emptyItemCount) {
        convertView = mAdapter.getView(mAdapter.getCount() - 1, convertView, parent);
        convertView.setVisibility(View.INVISIBLE);
        return convertView;
    }
    int numFootersAndPlaceholders = getFootersCount() * mNumColumns;
    if (position < numHeadersAndPlaceholders + mAdapter.getCount() + emptyItemCount + numFootersAndPlaceholders) {
        View footerViewContainer = mFooterViewInfos.get((position - numHeadersAndPlaceholders - mAdapter.getCount() - emptyItemCount) / mNumColumns).viewContainer;
        if (position % mNumColumns == 0) {
            return footerViewContainer;
        } else {
            convertView = new View(parent.getContext());
            convertView.setVisibility(View.INVISIBLE);
            convertView.setMinimumHeight(footerViewContainer.getHeight());
            return convertView;
        }
    }
    throw new ArrayIndexOutOfBoundsException(position);
}

Output:
             if (adjPosition < adapterCount) {
-                return mAdapter.getView(adjPosition, convertView, parent);
+                convertView = mAdapter.getView(adjPosition, convertView, parent);
+                convertView.setVisibility(View.VISIBLE);
+                return convertView;
             }


Input:
protected void setStateOfTitle() {
    boolean isTitleEnabled = getAxisForProcessing().getTitle().isVisible();
    txtTitle.setEnabled(isTitleEnabled);
    setToggleButtonEnabled(BUTTON_TITLE, isTitleEnabled);
}

Output:
 protected void setStateOfTitle() {
-    boolean isTitleEnabled = getAxisForProcessing().getTitle().isVisible();
+    boolean isTitleEnabled = isTitleEnabled();
     txtTitle.setEnabled(isTitleEnabled);


Input:
public void setup() throws Exception {
    log.log(LogService.LOG_DEBUG, "String_Node_Str");
    String devnode_gps = "String_Node_Str" + Integer.toString(slotId);
    String devnode_gpscontrol = "String_Node_Str" + Integer.toString(slotId + 1);
    GPS gps = new GPS();
    CharDeviceUtils.openDeviceWithRetry(gps, devnode_gps, FCNTL_H.O_RDWR | FCNTL_H.O_NONBLOCK, 2);
    int result = gps.init();
    if (result < 0) {
        throw new RuntimeException("String_Node_Str" + devnode_gpscontrol);
    }
    gpsis = new CharDeviceInputStream(gps);
    log.log(LogService.LOG_DEBUG, "String_Node_Str");
    long delay = getReadDelay();
    log.log(LogService.LOG_DEBUG, "String_Node_Str" + delay);
    gpsd = new NMEARawFeed(gpsis, delay);
    nmeaProvider = new NMEASentenceProvider(gpsd.getInputStream(), log);
    gpscontrol = new GPSControl();
    CharDeviceUtils.openDeviceWithRetry(gpscontrol, devnode_gpscontrol, 2);
    log.log(LogService.LOG_DEBUG, "String_Node_Str");
}

Output:
     gpsd = new NMEARawFeed(gpsis, delay);
-    nmeaProvider = new NMEASentenceProvider(gpsd.getInputStream(), log);
+    nmeaProvider = new NMEASentenceProvider(gpsd.getInputStream(), context);
     gpscontrol = new GPSControl();


Input:
private void setContextsView(IProcess2 process) {
    IRunProcessService service = DesignerPlugin.getDefault().getRunProcessService();
    service.setActiveProcess(process, false);
    Contexts.switchToCurContextsView();
}

Output:
     IRunProcessService service = DesignerPlugin.getDefault().getRunProcessService();
-    service.setActiveProcess(process, false);
+    service.setActiveProcess(process, true);
     Contexts.switchToCurContextsView();


Input:
public String toString() {
    return "String_Node_Str" + getMethod().getDeclaringClass().getSimpleName() + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + getMethod().getDeclaringClass().getSimpleName() + "String_Node_Str";
+    return "String_Node_Str" + getResource().getResourceClass().getSimpleName() + "String_Node_Str";
 }


Input:
public void testPutSignatureTwiceWithDifferentConfidence() {
    invocationsCollector.put(jvmUuid1, "String_Node_Str", now, 100L, EXACT_MATCH);
    invocationsCollector.put(jvmUuid1, "String_Node_Str", now, 100L, FOUND_IN_PARENT_CLASS);
    List<SignatureEntry> signatures = invocationsCollector.getNotUploadedInvocations(jvmUuid1);
    assertThat(signatures, hasSize(1));
    assertThat(signatures.get(0).getConfidence(), is(FOUND_IN_PARENT_CLASS));
}

Output:
 public void testPutSignatureTwiceWithDifferentConfidence() {
-    invocationsCollector.put(jvmUuid1, "String_Node_Str", now, 100L, EXACT_MATCH);
-    invocationsCollector.put(jvmUuid1, "String_Node_Str", now, 100L, FOUND_IN_PARENT_CLASS);
+    invocationsCollector.put(jvmUuid1, now - 100L, "String_Node_Str", now, EXACT_MATCH);
+    invocationsCollector.put(jvmUuid1, now - 100L, "String_Node_Str", now, FOUND_IN_PARENT_CLASS);
     List<SignatureEntry> signatures = invocationsCollector.getNotUploadedInvocations(jvmUuid1);


Input:
public void setMaximumTime(Calendar cal) {
    throw new RuntimeException("String_Node_Str");
}

Output:
 public void setMaximumTime(Calendar cal) {
-    throw new RuntimeException("String_Node_Str");
+    int max = cal.get(Calendar.HOUR_OF_DAY) * 60 + cal.get(Calendar.MINUTE);
+    if (max < minimumTime)
+        throw new IllegalArgumentException("String_Node_Str");
+    maximumTime = max;
+    if (currentTimeEnd > maximumTime) {
+        currentTimeEnd = maximumTime;
+    }
+    if (currentTimeStart > maximumTime) {
+        currentTimeStart = Math.max(minimumTime, maximumTime - minimumDuration);
+    }
+    currentDay = (Calendar) cal.clone();
 }


Input:
private HTMLRenderOption createHTMLRenderOption(boolean svgFlag, String servletPath, HttpServletRequest request) {
    String baseURL = null;
    boolean isDesigner = ParameterAccessor.isDesigner(request);
    if (!isDesigner)
        baseURL = ParameterAccessor.getBaseURL();
    if (baseURL == null)
        baseURL = "String_Node_Str";
    baseURL += request.getContextPath();
    HTMLRenderOption renderOption = new HTMLRenderOption();
    renderOption.setImageDirectory(ParameterAccessor.getImageTempFolder(request));
    renderOption.setBaseImageURL(baseURL + imageBaseUrl);
    if (servletPath != null && servletPath.length() > 0) {
        renderOption.setBaseURL(baseURL + servletPath);
    } else {
        renderOption.setBaseURL(baseURL + IBirtConstants.SERVLET_PATH_RUN);
    }
    renderOption.setEnableAgentStyleEngine(ParameterAccessor.isAgentStyle(request));
    renderOption.setSupportedImageFormats(svgFlag ? "String_Node_Str" : "String_Node_Str");
    return renderOption;
}

Output:
         baseURL = ParameterAccessor.getBaseURL();
-    if (baseURL == null)
-        baseURL = "String_Node_Str";
+    if (baseURL == null) {
+        if (ParameterAccessor.isOpenAsAttachment(request) || !ParameterAccessor.PARAM_FORMAT_HTML.equalsIgnoreCase(ParameterAccessor.getFormat(request))) {
+            baseURL = request.getScheme() + "String_Node_Str" + request.getServerName() + "String_Node_Str" + request.getServerPort();
+        } else {
+            baseURL = "String_Node_Str";
+        }
+    }
     baseURL += request.getContextPath();


Input:
private void doResource() {
    dashboardService.addWidgetToDashboard(new DashboardWidget("String_Node_Str"));
}

Output:
 private void doResource() {
-    dashboardService.addWidgetToDashboard(new DashboardWidget("String_Node_Str"));
+    DashboardWidget newWidget = new DashboardWidget("String_Node_Str");
+    configureFixedWidgets(newWidget);
+    newWidget.setTitle("String_Node_Str");
+    newWidget.setSeriesField("String_Node_Str");
+    dashboardService.addWidgetToDashboard(newWidget);
 }


Input:
public int compare(Event event, Event event2) {
    try {
        if (event.getEventType() == event2.getEventType()) {
            int districtSort = ((Integer) event.getDistrictEnum()).compareTo(event2.getDistrictEnum());
            if (districtSort == 0) {
                return event.getStartDate().compareTo(event2.getStartDate());
            } else {
                return districtSort;
            }
        } else {
            int typeCompare = event.getEventType().compareTo(event2.getEventType());
            if (typeCompare == 0 && event.getEventType() == EventHelper.TYPE.DISTRICT) {
                return ((Integer) event.getDistrictEnum()).compareTo(event2.getDistrictEnum());
            } else {
                return typeCompare;
            }
        }
    } catch (BasicModel.FieldNotDefinedException e) {
        Log.e(Constants.LOG_TAG, "String_Node_Str" + e.getMessage());
        return 0;
    }
}

Output:
             if (districtSort == 0) {
-                return event.getStartDate().compareTo(event2.getStartDate());
+                int eventSort = event.getStartDate().compareTo(event2.getStartDate());
+                if (eventSort == 0) {
+                    return event.getShortName().compareTo(event2.getShortName());
+                } else {
+                    return eventSort;
+                }
             } else {


Input:
public void setParameter(int pid, int value) {
    log.debug("String_Node_Str" + pid + "String_Node_Str" + value);
    if ((pid & 0xc3) != 0)
        throw new IllegalArgumentException("String_Node_Str" + pid);
    serialWrite(new int[] { SET_PARAMETER_MESSAGE | pid | (value >> 8), value & 0xff });
}

Output:
         throw new IllegalArgumentException("String_Node_Str" + pid);
-    serialWrite(new int[] { SET_PARAMETER_MESSAGE | pid | (value >> 8), value & 0xff });
+    serialWrite(new int[] { SET_PARAMETER_MESSAGE | pid | (value >> 8 & 0x3), value & 0xff });
 }


Input:
public boolean equals(Object o) {
    if (this == o)
        return true;
    if (o == null || getClass() != o.getClass())
        return false;
    CustomField that = (CustomField) o;
    if (id != that.id)
        return false;
    if (name != null ? !name.equals(that.name) : that.name != null)
        return false;
    if (value != null ? !value.equals(that.value) : that.value != null)
        return false;
    if (values != null ? !values.equals(that.value) : that.values != null)
        return false;
    return true;
}

Output:
         return false;
-    if (values != null ? !values.equals(that.value) : that.values != null)
+    if (values != null ? !values.equals(that.values) : that.values != null)
         return false;


Input:
public void serviceChanged(ServiceEvent event) {
    Object sService = AdvancedConfigActivator.bundleContext.getService(event.getServiceReference());
    if (!(sService instanceof ConfigurationForm))
        return;
    ConfigurationForm configForm = (ConfigurationForm) sService;
    if (!configForm.isAdvanced())
        return;
    switch(event.getType()) {
        case ServiceEvent.REGISTERED:
            if (logger.isInfoEnabled())
                logger.info("String_Node_Str");
            this.addConfigForm(configForm);
            break;
        case ServiceEvent.UNREGISTERING:
            this.removeConfigForm(configForm);
            break;
    }
}

Output:
     ConfigurationForm configForm = (ConfigurationForm) sService;
-    if (!configForm.isAdvanced())
+    if ((configForm == this) || !configForm.isAdvanced())
         return;


Input:
private boolean isSubredditRequest(String path) {
    boolean isSubredditRequest = false;
    log("String_Node_Str" + path);
    if (path.equalsIgnoreCase("String_Node_Str")) {
        isSubredditRequest = true;
    }
    return isSubredditRequest;
}

Output:
     log("String_Node_Str" + path);
-    if (path.equalsIgnoreCase("String_Node_Str")) {
+    if (path != null && path.contains("String_Node_Str")) {
         isSubredditRequest = true;


Input:
private void interpret(InstructionList il, Map<InstructionHandle, T> start, boolean initialize) {
    if (initialize) {
        InstructionHandle ih = il.getStart();
        while (ih != null) {
            results.put(ih, analysis.bottom());
            ih = ih.getNext();
        }
        results.putAll(start);
    } else {
        for (InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
            if (results.containsKey(ih))
                continue;
            if (ih.getPrev() == null && !ih.hasTargeters()) {
                results.put(ih, analysis.initial(ih));
            } else {
                results.put(ih, analysis.bottom());
                if (ih.hasTargeters()) {
                    for (InstructionTargeter targeter : ih.getTargeters()) {
                        if (targeter instanceof CodeExceptionGen) {
                            results.put(ih, analysis.initial((CodeExceptionGen) targeter));
                            break;
                        }
                    }
                }
            }
        }
    }
    LinkedList<Edge> worklist = new LinkedList<Edge>();
    for (InstructionHandle ih : start.keySet()) {
        if (initialize) {
            worklist.addAll(getOutEdges(ih));
        } else if (ih.getPrev() == null && !ih.hasTargeters()) {
            worklist.addAll(getOutEdges(ih));
        } else {
            worklist.addAll(getInEdges(il, ih));
        }
    }
    while (!worklist.isEmpty()) {
        Edge edge = worklist.removeFirst();
        InstructionHandle tail = edge.getTail();
        InstructionHandle head = edge.getHead();
        T tailValue = results.get(tail);
        T headValue = results.get(head);
        T transferred = analysis.transfer(tailValue, edge);
        if (!analysis.compare(transferred, headValue)) {
            T newValue = analysis.join(transferred, headValue);
            results.put(head, newValue);
            if (edge.getType() == EdgeType.EXIT_EDGE) {
                continue;
            }
            List<Edge> outEdges = getOutEdges(head);
            for (Edge outEdge : outEdges) {
                if (worklist.contains(outEdge)) {
                    continue;
                }
                if (outEdges.size() > 1) {
                    worklist.addLast(outEdge);
                } else {
                    worklist.addFirst(outEdge);
                }
            }
        }
    }
}

Output:
                 continue;
-            if (ih.getPrev() == null && !ih.hasTargeters()) {
+            if (ih.getPrev() == null) {
                 results.put(ih, analysis.initial(ih));


Input:
public static boolean hasRewardBlock(Player player) {
    return player.hasPermission(permissionRewardBlock);
}

Output:
 public static boolean hasRewardBlock(Player player) {
-    return player.hasPermission(permissionRewardBlock);
+    return player.hasPermission(REWARDS_BLOCK);
 }


Input:
void setParametersToDefault() {
    numCycles = 5;
    stepSize = 1.0;
    iterationsPerCycle = 100;
    sprintConstant = 0.5;
    stepDampingFactor = 0.5;
}

Output:
     numCycles = 5;
-    stepSize = 1.0;
-    iterationsPerCycle = 100;
+    stepSize = 1;
+    iterationsPerCycle = 10;
     sprintConstant = 0.5;


Input:
private long getRecoverInterval() {
    long recoverInterval = proxyFactoryBean.getRecoverInterval();
    if (recoverInterval <= TOO_FREQUENT) {
        LOGGER.warn("String_Node_Str" + recoverInterval + "String_Node_Str" + DEFAULT_RECOVER_INTERVAL);
        recoverInterval = DEFAULT_RECOVER_INTERVAL;
    }
    return recoverInterval;
}

Output:
     if (recoverInterval <= TOO_FREQUENT) {
-        LOGGER.warn("String_Node_Str" + recoverInterval + "String_Node_Str" + DEFAULT_RECOVER_INTERVAL);
+        LOGGER.log(Level.WARNING, "String_Node_Str" + recoverInterval + "String_Node_Str" + DEFAULT_RECOVER_INTERVAL);
         recoverInterval = DEFAULT_RECOVER_INTERVAL;


Input:
public boolean tryPut(Data dataKey, Object value, long ttl) {
    checkIfLoaded();
    Record record = records.get(dataKey);
    if (record == null) {
        value = mapService.interceptPut(name, null, value);
        record = mapService.createRecord(name, dataKey, value, ttl);
        mapStoreWrite(record, dataKey, value);
        records.put(dataKey, record);
        updateSizeEstimator(calculateRecordSize(record));
    } else {
        value = mapService.interceptPut(name, record.getValue(), value);
        mapStoreWrite(record, dataKey, value);
        updateSizeEstimator(-calculateRecordSize(record));
        setRecordValue(record, value);
        updateSizeEstimator(calculateRecordSize(record));
        updateTtl(record, ttl);
    }
    saveIndex(record);
    return true;
}

Output:
     Record record = records.get(dataKey);
-    if (record == null) {
+    if (record == null || record.getValue() == null) {
         value = mapService.interceptPut(name, null, value);


Input:
private static String getCurrentDatetime() {
    String pattern = "String_Node_Str";
    SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    return sdf.format(new Date());
}

Output:
     String pattern = "String_Node_Str";
-    SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+    SimpleDateFormat sdf = new SimpleDateFormat(pattern, Locale.ROOT);
     return sdf.format(new Date());


Input:
public void testSelectAggregateEntitySelect() {
    CriteriaBuilder<Tuple> cb = cbf.create(em, Tuple.class).from(Document.class, "String_Node_Str").selectCase().when("String_Node_Str").gtExpression("String_Node_Str").thenExpression("String_Node_Str").otherwiseExpression("String_Node_Str").select("String_Node_Str").orderByDesc("String_Node_Str");
    String objectQuery = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + groupBy("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", renderNullPrecedenceGroupBy("String_Node_Str")) + "String_Node_Str" + renderNullPrecedence("String_Node_Str", "String_Node_Str", "String_Node_Str");
    assertEquals(objectQuery, cb.getQueryString());
    cb.getResultList();
}

Output:
     CriteriaBuilder<Tuple> cb = cbf.create(em, Tuple.class).from(Document.class, "String_Node_Str").selectCase().when("String_Node_Str").gtExpression("String_Node_Str").thenExpression("String_Node_Str").otherwiseExpression("String_Node_Str").select("String_Node_Str").orderByDesc("String_Node_Str");
-    String objectQuery = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + groupBy("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", renderNullPrecedenceGroupBy("String_Node_Str")) + "String_Node_Str" + renderNullPrecedence("String_Node_Str", "String_Node_Str", "String_Node_Str");
+    String objectQuery = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + groupBy("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", renderNullPrecedenceGroupBy("String_Node_Str")) + "String_Node_Str" + renderNullPrecedence("String_Node_Str", "String_Node_Str", "String_Node_Str");
     assertEquals(objectQuery, cb.getQueryString());


Input:
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
    monitor.beginTask("String_Node_Str", IProgressMonitor.UNKNOWN);
    if (resultSetTable != null && !resultSetTable.isDisposed()) {
        ClassLoader oldContextLoader = Thread.currentThread().getContextClassLoader();
        ClassLoader parentLoader = oldContextLoader;
        if (parentLoader == null)
            parentLoader = this.getClass().getClassLoader();
        ClassLoader newContextLoader = DataSetProvider.getCustomScriptClassLoader(parentLoader, ((DataSetEditor) getContainer()).getHandle().getModuleHandle());
        Thread.currentThread().setContextClassLoader(newContextLoader);
        Map dataSetBindingMap = new HashMap();
        Map dataSourceBindingMap = new HashMap();
        ModuleHandle handle;
        DataSetHandle dsHandle = ((DataSetEditor) getContainer()).getHandle();
        handle = dsHandle.getModuleHandle();
        try {
            if (handle instanceof ReportDesignHandle) {
                EngineConfig ec = new EngineConfig();
                ec.getAppContext().put(EngineConstants.APPCONTEXT_CLASSLOADER_KEY, newContextLoader);
                ReportEngine engine = (ReportEngine) new ReportEngineFactory().createReportEngine(ec);
                DataSetUIUtil.clearPropertyBindingMap(dsHandle, dataSetBindingMap, dataSourceBindingMap);
                DummyEngineTask engineTask = new DummyEngineTask(engine, new ReportEngineHelper(engine).openReportDesign((ReportDesignHandle) handle), handle);
                DataRequestSession session = engineTask.getDataSession();
                session.getDataSessionContext().getAppContext().put(ResourceIdentifiers.ODA_APP_CONTEXT_KEY_CONSUMER_RESOURCE_IDS, DTPUtil.getInstance().createResourceIdentifiers());
                Map appContext = new HashMap();
                appContext.put(DataEngine.MEMORY_DATA_SET_CACHE, new Integer(((DataSetHandle) getContainer().getModel()).getRowFetchLimit()));
                engineTask.setAppContext(appContext);
                engineTask.run();
                IQueryResults resultSet = executeProcess(session, engineTask.getExecutionContext());
                populateRecords(resultSet);
                engineTask.close();
                engine.destroy();
                monitor.done();
            } else {
                DataSessionContext context;
                context = new DataSessionContext(DataSessionContext.MODE_DIRECT_PRESENTATION, ((DataSetEditor) getContainer()).getHandle().getModuleHandle());
                DataRequestSession session = DataRequestSession.newSession(context);
                Map appContext = new HashMap();
                appContext.put(DataEngine.MEMORY_DATA_SET_CACHE, new Integer(((DataSetHandle) getContainer().getModel()).getRowFetchLimit()));
                appContext.put(ResourceIdentifiers.ODA_APP_CONTEXT_KEY_CONSUMER_RESOURCE_IDS, DTPUtil.getInstance().createResourceIdentifiers());
                if (context.getAppContext() != null) {
                    appContext.putAll(context.getAppContext());
                }
                context.setAppContext(appContext);
                IQueryResults resultSet = executeProcess(session, null);
                populateRecords(resultSet);
                session.shutdown();
            }
        } catch (BirtException e) {
            ExceptionHandler.handle(e);
        } finally {
            try {
                DataSetUIUtil.resetPropertyBinding(dsHandle, dataSetBindingMap, dataSourceBindingMap);
            } catch (SemanticException e) {
            }
        }
        Thread.currentThread().setContextClassLoader(oldContextLoader);
    }
}

Output:
                 DataSetUIUtil.clearPropertyBindingMap(dsHandle, dataSetBindingMap, dataSourceBindingMap);
-                DummyEngineTask engineTask = new DummyEngineTask(engine, new ReportEngineHelper(engine).openReportDesign((ReportDesignHandle) handle), handle);
+                DummyEngineTask engineTask = new DummyEngineTask(engine, new ReportEngineHelper(engine).openReportDesign(copiedReport), copiedReport);
                 DataRequestSession session = engineTask.getDataSession();


Input:
private void download(final DownloadAction downLoadAction, final boolean supportNewSaveFileName, File saveFile, boolean overwrite) {
    try {
        downLoadAction.download(saveFile, overwrite);
    } catch (DownloadException e1) {
        handleDownloadException(downLoadAction, e1, supportNewSaveFileName);
    }
}

Output:
     try {
-        downLoadAction.download(saveFile, overwrite);
+        downLoadAction.download(newSaveFile, overwrite);
     } catch (DownloadException e1) {


Input:
public Object getGroup(int groupPosition) {
    return groups.get(groupPosition);
}

Output:
 public Object getGroup(int groupPosition) {
-    return groups.get(groupPosition);
+    return mGroups.get(groupPosition);
 }


Input:
public static void main(String[] args) {
    game = new Game();
    game.set_state(Game.GameModes.InGame);
    game.run();
}

Output:
     game = new Game();
-    game.set_state(Game.GameModes.InGame);
+    game.set_state(Game.GameModes.MainMenu);
     game.run();


Input:
public CommandResult execute(CommandSource source, CommandContext context) throws CommandException {
    if (source instanceof Player) {
        Player player = (Player) source;
        String playerFactionName = FactionLogic.getFactionName(player.getUniqueId());
        if (playerFactionName != null) {
            if (FactionLogic.getHome(playerFactionName) != null) {
                World world = player.getWorld();
                if (FactionLogic.isHomeInWorld(world.getUniqueId(), playerFactionName)) {
                    EagleFactions.getEagleFactions().getLogger().info("String_Node_Str");
                    Vector3i home = FactionLogic.getHome(playerFactionName);
                    EagleFactions.getEagleFactions().getLogger().info("String_Node_Str");
                    player.setLocation(player.getLocation().setPosition(new Vector3d(home.getX(), player.getLocation().getY(), home.getZ())));
                    source.sendMessage(Text.of(PluginInfo.PluginPrefix, "String_Node_Str"));
                } else {
                    source.sendMessage(Text.of(PluginInfo.ErrorPrefix, "String_Node_Str"));
                }
            } else {
                source.sendMessage(Text.of(PluginInfo.ErrorPrefix, TextColors.RED, "String_Node_Str"));
            }
        } else {
            source.sendMessage(Text.of(PluginInfo.ErrorPrefix, TextColors.RED, "String_Node_Str"));
        }
    } else {
        source.sendMessage(Text.of(PluginInfo.ErrorPrefix, TextColors.RED, "String_Node_Str"));
    }
    return CommandResult.success();
}

Output:
                     Vector3i home = FactionLogic.getHome(playerFactionName);
-                    EagleFactions.getEagleFactions().getLogger().info("String_Node_Str");
-                    player.setLocation(player.getLocation().setPosition(new Vector3d(home.getX(), player.getLocation().getY(), home.getZ())));
+                    player.setLocation(player.getLocation().setPosition(new Vector3d(home.getX(), home.getY(), home.getZ())));
                     source.sendMessage(Text.of(PluginInfo.PluginPrefix, "String_Node_Str"));


Input:
public void setUp() {
    ArchiveUtil.DeleteAllFiles(new File(ARCHIVE_NAME));
}

Output:
 public void setUp() {
-    ArchiveUtil.DeleteAllFiles(new File(ARCHIVE_NAME));
+    ArchiveUtil.deleteAllFiles(new File(ARCHIVE_NAME));
 }


Input:
private boolean parseEdge(ArrayList list) {
    EdgeDraft edgeDraft = container.factory().newEdgeDraft();
    for (int i = 0; i < list.size(); i += 2) {
        String key = (String) list.get(i);
        Object value = list.get(i + 1);
        if ("String_Node_Str".equals(key)) {
            NodeDraft source = container.getNode(value.toString());
            edgeDraft.setSource(source);
        } else if ("String_Node_Str".equals(key)) {
            NodeDraft target = container.getNode(value.toString());
            edgeDraft.setTarget(target);
        } else if ("String_Node_Str".equals(key)) {
            if (value instanceof Double) {
                edgeDraft.setWeight(((Double) value).floatValue());
            }
        } else if ("String_Node_Str".equals(key)) {
            edgeDraft.setLabel(value.toString());
        }
    }
    boolean ret = addEdgeAttributes(edgeDraft, "String_Node_Str", list);
    container.addEdge(edgeDraft);
    return ret;
}

Output:
             edgeDraft.setTarget(target);
-        } else if ("String_Node_Str".equals(key)) {
+        } else if ("String_Node_Str".equals(key) || "String_Node_Str".equals(key)) {
             if (value instanceof Double) {


Input:
public double apply(final IDoubleSizedIterable a, final IDoubleSizedIterable b) {
    final IDoubleSizedIterator a_it = a.iterator();
    final IDoubleSizedIterator b_it = a.iterator();
    double acc = 0;
    while (a_it.hasNext() && b_it.hasNext()) {
        double d = a_it.nextPrimitive() - b_it.nextPrimitive();
        if (!isNaN(d))
            acc += d * d;
    }
    return Math.sqrt(acc);
}

Output:
     final IDoubleSizedIterator a_it = a.iterator();
-    final IDoubleSizedIterator b_it = a.iterator();
+    final IDoubleSizedIterator b_it = b.iterator();
     double acc = 0;


Input:
private <T extends Serializable> void addPluginToPluginTypeMapping(Plugin<T> plugin) {
    PluginInfo pluginInfo = getPluginInfo(plugin.getName());
    PluginType pluginType = plugin.getType();
    if (pluginInfoPerType.get(pluginType) == null) {
        List<PluginInfo> list = new ArrayList<>();
        list.add(pluginInfo);
        pluginInfoPerType.put(pluginType, list);
    } else if (!pluginInfoPerType.get(pluginType).contains(plugin)) {
        pluginInfoPerType.get(pluginType).add(pluginInfo);
    }
}

Output:
 private <T extends Serializable> void addPluginToPluginTypeMapping(Plugin<T> plugin) {
-    PluginInfo pluginInfo = getPluginInfo(plugin.getName());
+    PluginInfo pluginInfo = getPluginInfo(plugin.getClass().getCanonicalName());
     PluginType pluginType = plugin.getType();


Input:
private static List processUnrelatedDimensions(List tuplesForAggregation, Evaluator evaluator) {
    RolapMember measure = (RolapMember) evaluator.getMembers()[0];
    if (measure.isCalculated()) {
        return tuplesForAggregation;
    }
    RolapCube virtualCube = (RolapCube) evaluator.getCube();
    RolapCube baseCube = ((RolapStoredMeasure) measure).getCube();
    if (virtualCube.shouldIgnoreUnrelatedDimensions(baseCube.getName())) {
        return ignoreUnrelatedDimensions(tuplesForAggregation, baseCube);
    } else if (shouldIgnoreMeasureForNonJoiningDimension()) {
        return ignoreMeasureForNonJoiningDimension(tuplesForAggregation, baseCube);
    }
    return tuplesForAggregation;
}

Output:
         return ignoreUnrelatedDimensions(tuplesForAggregation, baseCube);
-    } else if (shouldIgnoreMeasureForNonJoiningDimension()) {
+    } else if (MondrianProperties.instance().IgnoreMeasureForNonJoiningDimension.get()) {
         return ignoreMeasureForNonJoiningDimension(tuplesForAggregation, baseCube);


Input:
public void waitForDone(int timeout) throws IncompleteException, IOException, InterruptedException {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    long timeoutMiliseconds = timeout * 60000;
    long remainingTime = timeoutMiliseconds;
    try {
        wait(new Callable<Boolean>() {
            public Boolean call() throws Exception {
                return monitor == null;
            }
        }, timeoutMiliseconds);
    } catch (Exception ex) {
        LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
    }
    if (monitor == IProgressMonitor.DONE_MONITOR) {
        return;
    }
    remainingTime = remainingTime - stopWatch.getTime();
    if (monitor != null && remainingTime > 0) {
        monitor.waitForDone(Math.round(remainingTime / 60000));
    }
    remainingTime = remainingTime - stopWatch.getTime();
    if (remainingTime > 0) {
        try {
            wait(new Callable<Boolean>() {
                public Boolean call() throws Exception {
                    SlaveComputer computer = slave.getComputer();
                    return computer != null && computer.isOffline();
                }
            }, remainingTime);
        } catch (Exception ex) {
            LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
        }
    }
}

Output:
     if (monitor != null && remainingTime > 0) {
-        monitor.waitForDone(Math.round(remainingTime / 60000));
+        monitor.waitForDone((int) Math.ceil(remainingTime / 60000));
     }


Input:
public void testTopCount(FoodMartTestCase test) {
    Axis axis = test.executeAxis2("String_Node_Str");
    String expected = "String_Node_Str" + nl + "String_Node_Str";
    test.assertEquals(expected, test.toString(axis.positions));
}

Output:
 public void testTopCount(FoodMartTestCase test) {
-    Axis axis = test.executeAxis2("String_Node_Str");
-    String expected = "String_Node_Str" + nl + "String_Node_Str";
-    test.assertEquals(expected, test.toString(axis.positions));
+    test.assertAxisReturns("String_Node_Str", "String_Node_Str" + nl + "String_Node_Str");
 }