Input:
public String getInternalName() {
    if (this.upperBoundCount > 0) {
        return this.upperBounds[0].getInternalName();
    }
    return "String_Node_Str";
}

Output:
 public String getInternalName() {
-    if (this.upperBoundCount > 0) {
-        return this.upperBounds[0].getInternalName();
+    if (this.upperBound != null) {
+        return this.upperBound.getInternalName();
     }


Input:
public static <T extends MVec> T[] copyOfArray(T[] orig) {
    if (orig == null) {
        return null;
    }
    T[] clone = Arrays.copyOf(orig, orig.length);
    for (int v = 0; v < clone.length; v++) {
        if (orig[v] != null) {
            clone[v] = (T) orig[v].copy();
        }
    }
    return clone;
}

Output:
         if (orig[v] != null) {
-            clone[v] = (T) orig[v].copy();
+            MVec copy = orig[v].copy();
+            if (!copy.getClass().equals(orig[v].getClass())) {
+                throw new RuntimeException(orig[v].getClass() + "String_Node_Str" + "String_Node_Str" + copy.getClass());
+            }
+            clone[v] = (T) copy;
         }


Input:
protected void checkDisplayNone(IContent content, boolean isStart) {
    if (isStart) {
        if (context.isDisplayNone()) {
            return;
        } else {
            if (PropertyUtil.isDisplayNone(content)) {
                contentDisplayNone = content;
                context.setDisplayNone(true);
            }
        }
    } else {
        if (context.isDisplayNone()) {
            if (PropertyUtil.isDisplayNone(content)) {
                if (contentDisplayNone == content) {
                    context.setDisplayNone(false);
                    contentDisplayNone = null;
                }
            }
        }
    }
}

Output:
             if (PropertyUtil.isDisplayNone(content)) {
-                if (contentDisplayNone == content) {
+                if (contentDisplayNone.getInstanceID() == content.getInstanceID()) {
                     context.setDisplayNone(false);


Input:
public void testGetRunTestsActionResponseStream() throws Exception {
    CoverageResponseStreamFactory factory = new CoverageResponseStreamFactory(new DefaultResponseStreamFactory(new ResponsePrinterFactory() {
        public TestResultPrinter getResponsePrinter(String xmlFile) {
            return printer;
        }
    }), null);
    ResponseStream responseStream = factory.getRunTestsActionResponseStream("String_Node_Str");
    assertNotNull(responseStream);
}

Output:
         }
-    }), null);
+    }, "String_Node_Str"), null);
     ResponseStream responseStream = factory.getRunTestsActionResponseStream("String_Node_Str");


Input:
public int createLight(float x, float y, Color pColor, float pSize) {
    int index = this.mLights.size() + 1;
    this.mLights.put(index, new PointLight(this.mGame.getEngine().getRayHandler(), DEFAULT_NUM_RAYS, pColor, pSize, x - (TILE_PIXEL_WIDTH / 2f), y - (TILE_PIXEL_HEIGHT / 2f)));
    return index;
}

Output:
     int index = this.mLights.size() + 1;
-    this.mLights.put(index, new PointLight(this.mGame.getEngine().getRayHandler(), DEFAULT_NUM_RAYS, pColor, pSize, x - (TILE_PIXEL_WIDTH / 2f), y - (TILE_PIXEL_HEIGHT / 2f)));
+    this.mLights.put(index, pLight);
     return index;


Input:
private void initialize(DataEngineImpl dataEngine, IBaseDataSetDesign dataSetDesign, Map appContext) throws DataException {
    dataSet = (IJointDataSetDesign) dataSetDesign;
    ResultIterator left = getSortedResultIterator(dataEngine, dataSet.getLeftDataSetDesignName(), appContext, dataSet.getJoinConditions(), true);
    ResultIterator right = getSortedResultIterator(dataEngine, dataSet.getRightDataSetDesignName(), appContext, dataSet.getJoinConditions(), false);
    IJoinConditionMatcher matcher = new JoinConditionMatcher(left.getOdiResult(), right.getOdiResult(), left.getScope(), right.getScope(), dataSet.getJoinConditions());
    JointResultMetadata meta = getJointResultMetadata(left, right);
    resultClass = meta.getResultClass();
    populator = JointDataSetPopulatorFactory.getBinaryTreeDataSetPopulator(left.getOdiResult(), right.getOdiResult(), meta, matcher, dataSet.getJoinType());
}

Output:
     ResultIterator right = getSortedResultIterator(dataEngine, dataSet.getRightDataSetDesignName(), appContext, dataSet.getJoinConditions(), false);
-    IJoinConditionMatcher matcher = new JoinConditionMatcher(left.getOdiResult(), right.getOdiResult(), left.getScope(), right.getScope(), dataSet.getJoinConditions());
+    this.left = left;
+    this.right = right;
+    this.joinType = dataSet.getJoinType();
+    this.matcher = new JoinConditionMatcher(left.getOdiResult(), right.getOdiResult(), left.getScope(), right.getScope(), dataSet.getJoinConditions());
     JointResultMetadata meta = getJointResultMetadata(left, right);


Input:
private void run() throws EmulationException {
    while (!isStopping) {
        if (cycles > nextOut && !debug) {
            printCPUSpeed(reg[PC]);
            nextOut = cycles + 20000007;
        }
        int pc = emulateOP(-1);
        if (pc >= 0) {
            if (execCounter != null) {
                execCounter[pc]++;
            }
            if (trace != null) {
                trace[tracePos++] = pc;
                if (tracePos >= trace.length)
                    tracePos = 0;
            }
            if (debug) {
                if (servicedInterrupt >= 0) {
                    disAsm.disassemble(pc, memory, reg, servicedInterrupt);
                } else {
                    disAsm.disassemble(pc, memory, reg);
                }
            }
        }
        if (cycles > nextSleep) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
            nextSleep = cycles + sleepRate;
        }
    }
    isStopping = isBreaking = false;
}

Output:
             try {
-                Thread.sleep(10);
+                Thread.sleep(100);
             } catch (Exception e) {


Input:
public byte[] modify(ClassLoader classLoader, String javassistClassName, ProtectionDomain protectedDomain, byte[] classFileBuffer) {
    if (logger.isInfoEnabled()) {
        logger.info("String_Node_Str", javassistClassName);
    }
    try {
        InstrumentClass ibatisClientImpl = byteCodeInstrumentor.getClass(classLoader, javassistClassName, classFileBuffer);
        List<MethodInfo> declaredMethods = ibatisClientImpl.getDeclaredMethods(getIbatisApiMethodFilter());
        for (MethodInfo method : declaredMethods) {
            Interceptor ibatisApiInterceptor = new IbatisSqlMapOperationInterceptor(serviceType);
            ibatisClientImpl.addScopeInterceptor(method.getName(), method.getParameterTypes(), ibatisApiInterceptor, scope);
        }
        return ibatisClientImpl.toBytecode();
    } catch (Throwable e) {
        this.logger.warn("String_Node_Str", javassistClassName, e.getMessage(), e);
        return null;
    }
}

Output:
             Interceptor ibatisApiInterceptor = new IbatisSqlMapOperationInterceptor(serviceType);
-            ibatisClientImpl.addScopeInterceptor(method.getName(), method.getParameterTypes(), ibatisApiInterceptor, scope);
+            ibatisClientImpl.addScopeInterceptor(method.getName(), method.getParameterTypes(), ibatisApiInterceptor, SCOPE);
         }


Input:
public void testCaptureAddFilesToLoadAndRun() throws Exception {
    Map<String, String> files = new LinkedHashMap<String, String>();
    files.put("String_Node_Str", "String_Node_Str");
    files.put("String_Node_Str", "String_Node_Str");
    files.put("String_Node_Str", "String_Node_Str");
    files.put("String_Node_Str", "String_Node_Str");
    FilesCache cache = new FilesCache(files);
    CapturedBrowsers capturedBrowsers = new CapturedBrowsers();
    StandaloneRunnerServlet runnerServlet = new StandaloneRunnerServlet(new BrowserHunter(capturedBrowsers), cache, new StandaloneRunnerFilesFilterImpl(), new SlaveResourceService("String_Node_Str"));
    runnerServlet.service("String_Node_Str", "String_Node_Str", "String_Node_Str");
    SlaveBrowser slaveBrowser = capturedBrowsers.getBrowser("String_Node_Str");
    assertNotNull(slaveBrowser.peekCommand());
    Command cmd = slaveBrowser.dequeueCommand();
    assertNotNull(cmd);
    assertEquals("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", cmd.getCommand());
    assertNotNull(slaveBrowser.peekCommand());
    cmd = slaveBrowser.dequeueCommand();
    assertNotNull(cmd);
    assertEquals("String_Node_Str", cmd.getCommand());
}

Output:
 public void testCaptureAddFilesToLoadAndRun() throws Exception {
-    Map<String, String> files = new LinkedHashMap<String, String>();
-    files.put("String_Node_Str", "String_Node_Str");
-    files.put("String_Node_Str", "String_Node_Str");
-    files.put("String_Node_Str", "String_Node_Str");
-    files.put("String_Node_Str", "String_Node_Str");
+    Map<String, FileData> files = new LinkedHashMap<String, FileData>();
+    files.put("String_Node_Str", new FileData("String_Node_Str", "String_Node_Str", 30));
+    files.put("String_Node_Str", new FileData("String_Node_Str", "String_Node_Str", 5));
+    files.put("String_Node_Str", new FileData("String_Node_Str", "String_Node_Str", 53));
+    files.put("String_Node_Str", new FileData("String_Node_Str", "String_Node_Str", 1));
     FilesCache cache = new FilesCache(files);


Input:
public void onCreate(Bundle savedInstanceState) {
    mEventManager.fire(new OnCreateEvent(savedInstanceState));
}

Output:
 public void onCreate(Bundle savedInstanceState) {
-    mEventManager.fire(new OnCreateEvent(savedInstanceState));
+    RoboGuice.getInjector(getFragment().getActivity()).injectMembersWithoutViews(getFragment());
 }


Input:
public String createNewPageNode(String nodeLabel) {
    try {
        if (nodeLabel == null || nodeLabel.length() == 0) {
            nodeLabel = "String_Node_Str" + getCurrentNumberOfTabs();
        }
        Page page = configService.createPageTemplate(UIWebOSTabPaneDashboard.PAGE_TEMPLATE, pageNavigation.getOwnerType(), pageNavigation.getOwnerId());
        page.setTitle(nodeLabel);
        List<PageNode> selectedPath = uiPortal.getSelectedPath();
        PageNode parentNode = null;
        if (selectedPath != null && selectedPath.size() > 1) {
            parentNode = selectedPath.get(selectedPath.size() - 2);
        }
        PageNode pageNode = new PageNode();
        pageNode.setLabel(nodeLabel);
        String uniqueNodeName = nodeLabel.toLowerCase().replace(' ', '_');
        if (nameExisted(uniqueNodeName)) {
            uniqueNodeName = uniqueNodeName + "String_Node_Str" + System.currentTimeMillis();
        }
        String fullName = (parentNode != null) ? parentNode.getUri() + "String_Node_Str" + uniqueNodeName : uniqueNodeName;
        page.setName(uniqueNodeName);
        pageNode.setName(uniqueNodeName);
        pageNode.setUri(fullName);
        pageNode.setPageReference(page.getPageId());
        if (parentNode == null) {
            pageNavigation.addNode(pageNode);
        } else if (parentNode.getChildren() != null) {
            parentNode.getChildren().add(pageNode);
        }
        dataService.create(page);
        dataService.save(pageNavigation);
        return fullName;
    } catch (Exception ex) {
        logger.info("String_Node_Str", ex);
        return null;
    }
}

Output:
         String fullName = (parentNode != null) ? parentNode.getUri() + "String_Node_Str" + uniqueNodeName : uniqueNodeName;
-        page.setName(uniqueNodeName);
+        page.setName(uniqueNodeName + "String_Node_Str" + page.hashCode());
         pageNode.setName(uniqueNodeName);


Input:
static VanillaSharedReplicatedHashMap<Integer, CharSequence> newSocketShmIntString(final byte identifier, final int serverPort, ClientPort... clientSocketChannelProviderMaps) throws IOException {
    final VanillaSharedReplicatedHashMapBuilder builder = new VanillaSharedReplicatedHashMapBuilder().entries(1000).identifier(identifier);
    final VanillaSharedReplicatedHashMap<Integer, CharSequence> result = builder.create(getPersistenceFile(), Integer.class, CharSequence.class);
    final int adjustedEntrySize = builder.entrySize() + 128;
    final short maxNumberOfEntriesPerChunk = ServerTcpSocketReplicator.toMaxNumberOfEntriesPerChunk(1024 * 8, adjustedEntrySize);
    for (ClientPort clientSocketChannelProvider : clientSocketChannelProviderMaps) {
        final SocketChannelEntryWriter socketChannelEntryWriter0 = new SocketChannelEntryWriter(adjustedEntrySize, maxNumberOfEntriesPerChunk, result);
        final SocketChannelEntryReader socketChannelEntryReader = new SocketChannelEntryReader(builder.entrySize(), result);
        ClientTcpSocketReplicator clientTcpSocketReplicator = new ClientTcpSocketReplicator(clientSocketChannelProvider, socketChannelEntryReader, socketChannelEntryWriter0, result);
        result.addCloseable(clientTcpSocketReplicator);
    }
    final SocketChannelEntryWriter socketChannelEntryWriter = new SocketChannelEntryWriter(adjustedEntrySize, maxNumberOfEntriesPerChunk, result);
    ServerTcpSocketReplicator serverTcpSocketReplicator = new ServerTcpSocketReplicator(result, result, serverPort, socketChannelEntryWriter);
    result.addCloseable(serverTcpSocketReplicator);
    return result;
}

Output:
     final VanillaSharedReplicatedHashMap<Integer, CharSequence> result = builder.create(getPersistenceFile(), Integer.class, CharSequence.class);
-    final int adjustedEntrySize = builder.entrySize() + 128;
+    final int adjustedEntrySize = result.maxEntrySize();
     final short maxNumberOfEntriesPerChunk = ServerTcpSocketReplicator.toMaxNumberOfEntriesPerChunk(1024 * 8, adjustedEntrySize);


Input:
public List<Object> findByRelation(String colName, Object colValue, Class entityClazz) {
    CompareOp operator = HBaseUtils.getOperator("String_Node_Str", false);
    EntityMetadata m = KunderaMetadataManager.getEntityMetadata(entityClazz);
    String columnFamilyName = m.getTableName();
    byte[] valueInBytes = HBaseUtils.getBytes(colValue);
    SingleColumnValueFilter f = null;
    f = new SingleColumnValueFilter(Bytes.toBytes(columnFamilyName), Bytes.toBytes(colName), operator, valueInBytes);
    try {
        return ((HBaseDataHandler) handler).scanData(f, m.getSchema(), entityClazz, m, columnFamilyName, colName);
    } catch (IOException ioe) {
        log.error("String_Node_Str", ioe);
        throw new KunderaException(ioe);
    } catch (InstantiationException ie) {
        log.error("String_Node_Str", ie);
        throw new KunderaException(ie);
    } catch (IllegalAccessException iae) {
        log.error("String_Node_Str", iae);
        throw new KunderaException(iae);
    }
}

Output:
     try {
-        return ((HBaseDataHandler) handler).scanData(f, m.getSchema(), entityClazz, m, columnFamilyName, colName);
+        List<AbstractManagedType> subManagedType = getSubManagedType(entityClazz, m);
+        if (!subManagedType.isEmpty()) {
+            for (AbstractManagedType subEntity : subManagedType) {
+                EntityMetadata subEntityMetadata = KunderaMetadataManager.getEntityMetadata(subEntity.getJavaType());
+                List results = ((HBaseDataHandler) handler).scanData(f, subEntityMetadata.getSchema(), subEntityMetadata.getEntityClazz(), subEntityMetadata, columnFamilyName, colName);
+                if (!results.isEmpty()) {
+                    output.addAll(results);
+                }
+            }
+        } else {
+            return ((HBaseDataHandler) handler).scanData(f, m.getSchema(), entityClazz, m, columnFamilyName, colName);
+        }
     } catch (IOException ioe) {


Input:
private RuleWrapper initRuleWrapper(int pos, Rule rule, FormItemContainer formLayout) {
    int i = counter.incrementAndGet();
    RuleWrapper wrapper = new RuleWrapper(rule);
    wrapper.setPosition(pos);
    SingleSelection roleEl = uifactory.addDropdownSingleselect("String_Node_Str" + i, null, formLayout, roleKeys, roleValues, null);
    String role = rule.getRole();
    for (int j = roleKeys.length; j-- > 0; ) {
        if (roleKeys[j].equals(role)) {
            roleEl.select(roleKeys[j], true);
        }
    }
    wrapper.setRoleEl(roleEl);
    SingleSelection attrNameEl = uifactory.addDropdownSingleselect("String_Node_Str" + i, null, formLayout, attrKeys, attrValues, null);
    String userAttributeKey = rule.getUserAttributeKey();
    for (int j = attrKeys.length; j-- > 0; ) {
        if (attrKeys[j].equals(userAttributeKey)) {
            attrNameEl.select(attrKeys[j], true);
        }
    }
    wrapper.setAttrNameEl(attrNameEl);
    TextElement valEl = uifactory.addTextElement("String_Node_Str" + i, null, 256, "String_Node_Str", formLayout);
    valEl.setValue(rule.getUserAttributeValue());
    wrapper.setAttrValueEl(valEl);
    TextElement landingPageEl = uifactory.addTextElement("String_Node_Str" + i, null, 256, "String_Node_Str", formLayout);
    landingPageEl.setValue(rule.getLandingPath());
    wrapper.setLandingPageEl(landingPageEl);
    formLayout.add(landingPageEl);
    DropdownItem chooser = new DropdownItem("String_Node_Str" + i, RCols.landingPageChooser.i18nKey(), getTranslator());
    chooser.setButton(true);
    chooser.setEmbbeded(true);
    fillChooser(wrapper, chooser, formLayout);
    wrapper.setLandingPageChooser(chooser);
    return wrapper;
}

Output:
     formLayout.add(landingPageEl);
-    DropdownItem chooser = new DropdownItem("String_Node_Str" + i, RCols.landingPageChooser.i18nKey(), getTranslator());
-    chooser.setButton(true);
-    chooser.setEmbbeded(true);
-    fillChooser(wrapper, chooser, formLayout);
+    FormLink chooser = uifactory.addFormLink("String_Node_Str" + i, "String_Node_Str", RCols.landingPageChooser.i18nKey(), null, formLayout, Link.BUTTON);
+    chooser.setIconRightCSS("String_Node_Str");
+    chooser.setUserObject(wrapper);
     wrapper.setLandingPageChooser(chooser);


Input:
public synchronized AddableDictionary createUserDictionary(AnyKeyboardContextProvider context) {
    if (mUserDictionary != null) {
        return mUserDictionary;
    }
    mUserDictionary = new SafeUserDictionary(context);
    return mUserDictionary;
}

Output:
     }
-    mUserDictionary = new SafeUserDictionary(context);
+    mUserDictionary = new SafeUserDictionary(context, locale);
+    mUserDictionary.loadDictionary();
+    mUserDictionaryLocale = locale;
     return mUserDictionary;


Input:
int getSpeed(OSMWay way) {
    int speed = PUSHING_SECTION_SPEED;
    String highwayTag = way.getTag("String_Node_Str");
    Integer highwaySpeed = highwaySpeeds.get(highwayTag);
    String s = way.getTag("String_Node_Str");
    if (!Helper.isEmpty(s)) {
        Integer surfaceSpeed = surfaceSpeeds.get(s);
        if (surfaceSpeed != null) {
            speed = surfaceSpeed;
            if (highwaySpeed != null && surfaceSpeed > highwaySpeed) {
                if (pushingSections.contains(highwayTag) && !highwayTag.equals("String_Node_Str"))
                    speed = highwaySpeed;
                else
                    speed = surfaceSpeed;
            }
        }
    } else {
        String tt = way.getTag("String_Node_Str");
        if (!Helper.isEmpty(tt)) {
            Integer tInt = trackTypeSpeeds.get(tt);
            if (tInt != null)
                speed = tInt;
        } else {
            if (highwaySpeed != null) {
                if (!way.hasTag("String_Node_Str"))
                    speed = highwaySpeed;
                else
                    speed = highwaySpeeds.get("String_Node_Str");
            }
        }
    }
    if ((speed > PUSHING_SECTION_SPEED) && (!way.hasTag("String_Node_Str", intendedValues) && isPushingSection(way))) {
        if (way.hasTag("String_Node_Str", "String_Node_Str"))
            speed = PUSHING_SECTION_SPEED / 2;
        else
            speed = PUSHING_SECTION_SPEED;
    }
    return speed;
}

Output:
             speed = surfaceSpeed;
-            if (highwaySpeed != null && surfaceSpeed > highwaySpeed) {
-                if (pushingSections.contains(highwayTag) && !highwayTag.equals("String_Node_Str"))
-                    speed = highwaySpeed;
-                else
-                    speed = surfaceSpeed;
+            if (highwaySpeed != null) {
+                if (surfaceSpeed > highwaySpeed) {
+                    if (pushingSections.contains(highwayTag) && !highwayTag.equals("String_Node_Str"))
+                        speed = highwaySpeed;
+                    else
+                        speed = surfaceSpeed;
+                } else {
+                    String cyclewayTag = way.getTag("String_Node_Str");
+                    if (cyclewayTag != null && "String_Node_Str".equals(cyclewayTag)) {
+                        speed = highwaySpeeds.get("String_Node_Str");
+                    }
+                }
             }


Input:
public void onReset() {
    mValueLineChart.resetZoom();
}

Output:
 public void onReset() {
-    mValueLineChart.resetZoom();
+    mValueLineChart.resetZoom(true);
 }


Input:
public static boolean isSqlScriptArtifact(AbstractDeploymentArtifact da) {
    if (da.getArtifactType().toString().equals(Constants.sqlScriptArtifactType.toString())) {
        return true;
    }
    return false;
}

Output:
 public static boolean isSqlScriptArtifact(AbstractDeploymentArtifact da) {
-    if (da.getArtifactType().toString().equals(Constants.sqlScriptArtifactType.toString())) {
+    if (da.getArtifactType().equals(Constants.sqlScriptArtifactType)) {
         return true;


Input:
public void create(IProgressMonitor monitor) throws Exception {
    IFile curPomFile = getPomFile();
    if (curPomFile == null) {
        return;
    }
    model = createModel();
    IContainer parent = curPomFile.getParent();
    Model pom = new Model();
    boolean route = "String_Node_Str".equals(getJobProcessor().getProcess().getComponentsType());
    if (route) {
        RouteProcess routeProcess = (RouteProcess) getJobProcessor().getProcess();
        boolean publishAsSnapshot = BooleanUtils.toBoolean((String) routeProcess.getAdditionalProperties().get(MavenConstants.NAME_PUBLISH_AS_SNAPSHOT));
        File featurePom = new File(parent.getLocation().toOSString() + File.separator + "String_Node_Str");
        Model fm = new Model();
        fm.setModelVersion("String_Node_Str");
        fm.setParent(model.getParent());
        fm.setGroupId(model.getGroupId());
        fm.setArtifactId(model.getArtifactId() + "String_Node_Str");
        fm.setName(model.getName() + "String_Node_Str");
        fm.setVersion(model.getVersion());
        fm.setPackaging("String_Node_Str");
        Build fmBuild = new Build();
        fmBuild.addPlugin(addFeaturesMavenPlugin(model.getProperties().getProperty("String_Node_Str")));
        fmBuild.addPlugin(addDeployFeatureMavenPlugin(fm.getArtifactId(), fm.getVersion(), publishAsSnapshot));
        Set<JobInfo> subjobs = getJobProcessor().getBuildChildrenJobs();
        if (subjobs != null && !subjobs.isEmpty()) {
            for (JobInfo subjob : subjobs) {
                if (isRoutelet(subjob) || isJob(subjob)) {
                    fmBuild.addPlugin(addFileInstallPlugin(subjob));
                }
            }
        }
        fm.setBuild(fmBuild);
        PomUtil.savePom(monitor, fm, featurePom);
    }
    pom.setModelVersion("String_Node_Str");
    pom.setGroupId(model.getGroupId());
    pom.setArtifactId(model.getArtifactId() + "String_Node_Str");
    pom.setName(model.getName() + "String_Node_Str");
    pom.setVersion(model.getVersion());
    pom.setPackaging("String_Node_Str");
    for (JobInfo job : getJobProcessor().getBuildChildrenJobs()) {
        if (isRoutelet(job)) {
            IPath currentProjectRootDir = getJobProcessor().getTalendJavaProject().getProject().getLocation();
            IPath routeletPomPath = getProcessor(job).getTalendJavaProject().getProjectPom().getLocation();
            String relativePomPath = routeletPomPath.makeRelativeTo(currentProjectRootDir).toString();
            pom.addModule(relativePomPath);
        }
    }
    pom.addModule("String_Node_Str");
    if (route) {
        pom.addModule("String_Node_Str");
    } else {
    }
    pom.setDependencies(model.getDependencies());
    if (pom.getBuild() == null) {
        pom.setBuild(new Build());
    }
    pom.getBuild().addPlugin(addSkipDeployFeatureMavenPlugin());
    File bd = new File(parent.getLocation().toOSString() + File.separator + "String_Node_Str");
    List<Profile> profiles = model.getProfiles();
    for (Profile profile : profiles) {
        if (profile.getId().equals("String_Node_Str")) {
            List<Plugin> plugins = profile.getBuild().getPlugins();
            for (Plugin plugin : plugins) {
                if (plugin.getArtifactId().equals("String_Node_Str")) {
                    PluginExecution pluginExecution = plugin.getExecutionsAsMap().get("String_Node_Str");
                    Xpp3Dom configuration = (Xpp3Dom) pluginExecution.getConfiguration();
                    Xpp3Dom archive = new Xpp3Dom("String_Node_Str");
                    Xpp3Dom manifestFile = new Xpp3Dom("String_Node_Str");
                    manifestFile.setValue("String_Node_Str");
                    archive.addChild(manifestFile);
                    configuration.addChild(archive);
                }
            }
        }
    }
    model.setName(model.getName() + "String_Node_Str");
    PomUtil.savePom(monitor, model, bd);
    PomUtil.savePom(monitor, pom, curPomFile);
    parent.refreshLocal(IResource.DEPTH_ONE, monitor);
    afterCreate(monitor);
}

Output:
                 if (isRoutelet(subjob) || isJob(subjob)) {
-                    fmBuild.addPlugin(addFileInstallPlugin(subjob));
+                    fmBuild.addPlugin(addFileInstallPlugin(subjob, ndx++));
                 }


Input:
public void execution() throws Exception {
    final ZonedDateTime validFrom = ZonedDateTime.now();
    final ZonedDateTime validUntil = validFrom.plusSeconds(8000);
    final LocalizedStrings name = en("String_Node_Str");
    final LocalizedStrings description = en("String_Node_Str");
    final String predicate = "String_Node_Str";
    final AbsoluteCartDiscountValue value = CartDiscountValue.ofAbsolute(MoneyImpl.of(10, EUR));
    final LineItemsTarget target = LineItemsTarget.of("String_Node_Str");
    final String sortOrder = "String_Node_Str";
    final boolean requiresDiscountCode = false;
    final CartDiscountDraft discountDraft = CartDiscountDraftBuilder.of(name, CartPredicate.of(predicate), value, target, sortOrder, requiresDiscountCode).validFrom(validFrom).validUntil(validUntil).description(description).isActive(false).build();
    cartDiscount = execute(CartDiscountCreateCommand.of(discountDraft));
    assertThat(cartDiscount.getName()).isEqualTo(name);
    assertThat(cartDiscount.getCartPredicate()).isEqualTo(predicate);
    assertThat(cartDiscount.getValue()).isEqualTo(value);
    assertThat(cartDiscount.getTarget()).isEqualTo(target);
    assertThat(cartDiscount.getSortOrder()).isEqualTo(sortOrder);
    assertThat(cartDiscount.isRequiringDiscountCode()).isEqualTo(requiresDiscountCode);
    assertThat(cartDiscount.getValidFrom()).contains(validFrom);
    assertThat(cartDiscount.getValidUntil()).contains(validUntil);
    assertThat(cartDiscount.getDescription()).contains(description);
    assertThat(cartDiscount.getReferences()).isEqualTo(Collections.emptyList());
}

Output:
 public void execution() throws Exception {
-    final ZonedDateTime validFrom = ZonedDateTime.now();
+    final ZonedDateTime validFrom = SphereTestUtils.now();
     final ZonedDateTime validUntil = validFrom.plusSeconds(8000);


Input:
boolean update(Context context, ActivityManager am) {
    final PackageManager pm = context.getPackageManager();
    mSequence++;
    boolean changed = false;
    List<ActivityManager.RunningServiceInfo> services = am.getRunningServices(MAX_SERVICES);
    final int NS = services != null ? services.size() : 0;
    for (int i = 0; i < NS; i++) {
        ActivityManager.RunningServiceInfo si = services.get(i);
        if (!si.started && si.clientLabel == 0) {
            continue;
        }
        if ((si.flags & ActivityManager.RunningServiceInfo.FLAG_PERSISTENT_PROCESS) != 0) {
            continue;
        }
        HashMap<String, ProcessItem> procs = mProcesses.get(si.uid);
        if (procs == null) {
            procs = new HashMap<String, ProcessItem>();
            mProcesses.put(si.uid, procs);
        }
        ProcessItem proc = procs.get(si.process);
        if (proc == null) {
            changed = true;
            proc = new ProcessItem(context, si.uid, si.process);
            procs.put(si.process, proc);
        }
        if (proc.mCurSeq != mSequence) {
            int pid = si.restarting == 0 ? si.pid : 0;
            if (pid != proc.mPid) {
                changed = true;
                if (proc.mPid != pid) {
                    if (proc.mPid != 0) {
                        mActiveProcesses.remove(proc.mPid);
                    }
                    if (pid != 0) {
                        mActiveProcesses.put(pid, proc);
                    }
                    proc.mPid = pid;
                }
            }
            proc.mDependentProcesses.clear();
            proc.mCurSeq = mSequence;
        }
        changed |= proc.updateService(context, si);
    }
    List<ActivityManager.RunningAppProcessInfo> processes = am.getRunningAppProcesses();
    final int NP = processes != null ? processes.size() : 0;
    for (int i = 0; i < NP; i++) {
        ActivityManager.RunningAppProcessInfo pi = processes.get(i);
        ProcessItem proc = mActiveProcesses.get(pi.pid);
        if (proc == null) {
            proc = mRunningProcesses.get(pi.pid);
            if (proc == null) {
                proc = new ProcessItem(context, pi.uid, pi.processName);
                proc.mPid = pi.pid;
                mRunningProcesses.put(pi.pid, proc);
            }
            proc.mDependentProcesses.clear();
        }
        proc.mRunningSeq = mSequence;
        proc.mRunningProcessInfo = pi;
    }
    int NRP = mRunningProcesses.size();
    for (int i = 0; i < NRP; i++) {
        ProcessItem proc = mRunningProcesses.valueAt(i);
        if (proc.mRunningSeq == mSequence) {
            int clientPid = proc.mRunningProcessInfo.importanceReasonPid;
            if (clientPid != 0) {
                ProcessItem client = mActiveProcesses.get(clientPid);
                if (client == null) {
                    client = mRunningProcesses.get(clientPid);
                }
                if (client != null) {
                    client.mDependentProcesses.put(proc.mPid, proc);
                }
            } else {
                proc.mClient = null;
            }
        } else {
            mRunningProcesses.remove(mRunningProcesses.keyAt(i));
        }
    }
    final int NAP = mActiveProcesses.size();
    for (int i = 0; i < NAP; i++) {
        ProcessItem proc = mActiveProcesses.valueAt(i);
        if (proc.mCurSeq == mSequence) {
            changed |= proc.buildDependencyChain(context, pm, mSequence);
        }
    }
    for (int i = 0; i < mProcesses.size(); i++) {
        HashMap<String, ProcessItem> procs = mProcesses.valueAt(i);
        Iterator<ProcessItem> pit = procs.values().iterator();
        while (pit.hasNext()) {
            ProcessItem pi = pit.next();
            if (pi.mCurSeq == mSequence) {
                pi.ensureLabel(pm);
                if (pi.mPid == 0) {
                    pi.mDependentProcesses.clear();
                }
            } else {
                changed = true;
                pit.remove();
                if (procs.size() == 0) {
                    mProcesses.remove(mProcesses.keyAt(i));
                }
                if (pi.mPid != 0) {
                    mActiveProcesses.remove(pi.mPid);
                }
                continue;
            }
            Iterator<ServiceItem> sit = pi.mServices.values().iterator();
            while (sit.hasNext()) {
                ServiceItem si = sit.next();
                if (si.mCurSeq != mSequence) {
                    changed = true;
                    sit.remove();
                }
            }
        }
    }
    if (changed) {
        ArrayList<BaseItem> newItems = new ArrayList<BaseItem>();
        mProcessItems.clear();
        for (int i = 0; i < mProcesses.size(); i++) {
            for (ProcessItem pi : mProcesses.valueAt(i).values()) {
                pi.mNeedDivider = false;
                pi.addDependentProcesses(newItems, mProcessItems);
                newItems.add(pi);
                if (pi.mPid > 0) {
                    mProcessItems.add(pi);
                }
                boolean needDivider = false;
                for (ServiceItem si : pi.mServices.values()) {
                    si.mNeedDivider = needDivider;
                    needDivider = true;
                    newItems.add(si);
                }
            }
        }
        synchronized (mLock) {
            mItems = newItems;
        }
    }
    mAllProcessItems.clear();
    mAllProcessItems.addAll(mProcessItems);
    int numBackgroundProcesses = 0;
    int numForegroundProcesses = 0;
    int numServiceProcesses = 0;
    NRP = mRunningProcesses.size();
    for (int i = 0; i < NRP; i++) {
        ProcessItem proc = mRunningProcesses.valueAt(i);
        if (proc.mCurSeq != mSequence) {
            if (proc.mRunningProcessInfo.importance >= ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND) {
                numBackgroundProcesses++;
                mAllProcessItems.add(proc);
            } else if (proc.mRunningProcessInfo.importance <= ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
                numForegroundProcesses++;
                mAllProcessItems.add(proc);
            } else {
                Log.i(TAG, "String_Node_Str" + proc.mProcessName + "String_Node_Str" + proc.mPid);
            }
        } else {
            numServiceProcesses++;
        }
    }
    long backgroundProcessMemory = 0;
    long foregroundProcessMemory = 0;
    long serviceProcessMemory = 0;
    try {
        final int numProc = mAllProcessItems.size();
        int[] pids = new int[numProc];
        for (int i = 0; i < numProc; i++) {
            pids[i] = mAllProcessItems.get(i).mPid;
        }
        Debug.MemoryInfo[] mem = ActivityManagerNative.getDefault().getProcessMemoryInfo(pids);
        for (int i = pids.length - 1; i >= 0; i--) {
            ProcessItem proc = mAllProcessItems.get(i);
            changed |= proc.updateSize(context, mem[i], mSequence);
            if (proc.mCurSeq == mSequence) {
                serviceProcessMemory += proc.mSize;
            } else if (proc.mRunningProcessInfo.importance >= ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND) {
                backgroundProcessMemory += proc.mSize;
            } else if (proc.mRunningProcessInfo.importance <= ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
                foregroundProcessMemory += proc.mSize;
            }
        }
    } catch (RemoteException e) {
    }
    synchronized (mLock) {
        mNumBackgroundProcesses = numBackgroundProcesses;
        mNumForegroundProcesses = numForegroundProcesses;
        mNumServiceProcesses = numServiceProcesses;
        mBackgroundProcessMemory = backgroundProcessMemory;
        mForegroundProcessMemory = foregroundProcessMemory;
        mServiceProcessMemory = serviceProcessMemory;
    }
    return changed;
}

Output:
     if (changed) {
-        ArrayList<BaseItem> newItems = new ArrayList<BaseItem>();
-        mProcessItems.clear();
+        ArrayList<ProcessItem> sortedProcesses = new ArrayList<ProcessItem>();
         for (int i = 0; i < mProcesses.size(); i++) {


Input:
public void triggerStreamClose(H2StreamProcessor streamProcessor) {
    if (closeTable.size() >= 512) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "String_Node_Str");
        }
        purgeCloseTable();
    }
    streamProcessor.setCloseTime(System.nanoTime());
    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
        Tr.debug(tc, "String_Node_Str" + streamProcessor.myID);
    }
    closeTable.put(streamProcessor.myID, streamProcessor);
    streamTable.remove(streamProcessor.myID);
}

Output:
     if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
-        Tr.debug(tc, "String_Node_Str" + streamProcessor.myID);
+        Tr.debug(tc, "String_Node_Str" + streamProcessor.getId());
     }


Input:
public void after(Object target, Object[] args, Object result, Throwable throwable) {
    if (isDebug) {
        logger.afterInterceptor(target, args);
    }
    Trace trace = traceContext.currentTraceObject();
    if (trace == null) {
        return;
    }
    try {
        trace.recordApi(descriptor);
        trace.recordException(throwable);
        if (args[0] instanceof String) {
            trace.recordAttribute(ANNOTATION_KEY_LENGTH_VALUE, ((String) args[0]).length());
        } else if (args[0] instanceof byte[]) {
            trace.recordAttribute(ANNOTATION_KEY_LENGTH_VALUE, (new String((byte[]) args[0])).length());
        } else if (args[0] instanceof File) {
            trace.recordAttribute(ANNOTATION_KEY_LENGTH_VALUE, ((File) args[0]).length());
        }
        trace.markAfterTime();
    } finally {
        trace.traceBlockEnd();
    }
}

Output:
         } else if (args[0] instanceof byte[]) {
-            trace.recordAttribute(ANNOTATION_KEY_LENGTH_VALUE, (new String((byte[]) args[0])).length());
+            trace.recordAttribute(ANNOTATION_KEY_LENGTH_VALUE, ((byte[]) args[0]).length);
         } else if (args[0] instanceof File) {


Input:
public void addRelation(String name) throws PtalonRuntimeException {
    String uniqueName = _actor.uniqueName(name);
    try {
        TypedIORelation relation = new TypedIORelation(_actor, uniqueName);
        _currentIfTree.setStatus(name, true);
        _currentIfTree.setEnteredIteration(name, _currentIfTree.entered);
        _currentIfTree.mapName(name, uniqueName);
    } catch (NameDuplicationException e) {
        throw new PtalonRuntimeException("String_Node_Str", e);
    } catch (IllegalActionException e) {
        throw new PtalonRuntimeException("String_Node_Str", e);
    }
}

Output:
         _currentIfTree.setStatus(name, true);
-        _currentIfTree.setEnteredIteration(name, _currentIfTree.entered);
+        if (_inNewWhileIteration()) {
+            if (_currentIfTree.isForStatement) {
+                _currentIfTree.setEnteredIteration(name, _currentIfTree.entered);
+            } else {
+                IfTree tree = _currentIfTree;
+                while (!tree.isForStatement) {
+                    tree = tree.getParent();
+                    if (tree == null) {
+                        throw new PtalonRuntimeException("String_Node_Str" + "String_Node_Str");
+                    }
+                }
+                _currentIfTree.setEnteredIteration(name, tree.entered);
+            }
+        } else {
+            _currentIfTree.setEnteredIteration(name, _currentIfTree.entered);
+        }
         _currentIfTree.mapName(name, uniqueName);


Input:
public int hashCode() {
    return Objects.hash(super.hashCode(), getDisplayName(), getShortDescription(), getLongDescription(), anchor, parentCategory, childrenCategories, terms, getClassifications());
}

Output:
 public int hashCode() {
-    return Objects.hash(super.hashCode(), getDisplayName(), getShortDescription(), getLongDescription(), anchor, parentCategory, childrenCategories, terms, getClassifications());
+    return Objects.hash(super.hashCode(), anchor, parentCategory, childrenCategories, terms);
 }


Input:
public static void main(String[] args) {
    final int WINDOW_WIDTH = 320;
    final int WINDOW_HEIGHT = 240;
    final String WINDOW_TITLE = "String_Node_Str";
    JFrame frame = new JFrame();
    final cubeTriangle joglMain = new cubeTriangle();
    frame.setContentPane(joglMain);
    frame.addWindowListener(new WindowAdapter() {

        public void windowClosing(WindowEvent e) {
            new Thread() {
                public void run() {
                    joglMain.animator.stop();
                    System.exit(0);
                }
            }.start();
        }
    });
    frame.setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    frame.setTitle(WINDOW_TITLE);
    frame.setVisible(true);
    joglMain.animator.start();
}

Output:
     final String WINDOW_TITLE = "String_Node_Str";
-    JFrame frame = new JFrame();
-    final cubeTriangle joglMain = new cubeTriangle();
-    frame.setContentPane(joglMain);
-    frame.addWindowListener(new WindowAdapter() {
+    try {
+        Runnable doActions = new Runnable() {


Input:
public void testBufferOverflow() throws IOException, InterruptedException {
    for (int i = 0; i < 1024; i++) {
        Thread.sleep(1000);
        System.out.println("String_Node_Str" + map2);
    }
}

Output:
     for (int i = 0; i < 1024; i++) {
-        Thread.sleep(1000);
+        Thread.sleep(5000);
+        map2.put(i * 2, "String_Node_Str");
         System.out.println("String_Node_Str" + map2);


Input:
public int parser(String body, int mode) {
    int re = 0;
    Pattern p;
    Matcher m;
    if (body == null)
        return 0;
    if (!body.contains("String_Node_Str")) {
        eMesg = body;
        return ERROR;
    }
    if (body.contains(OFFENSIVE_STRING)) {
        return OFFENSIVE;
    }
    if (body.contains(PINING_STRING)) {
        return PINING;
    }
    p = Pattern.compile("String_Node_Str");
    m = p.matcher(body);
    if (m.find()) {
        eMesg = m.group(1);
        return ERROR;
    }
    if ((mode & DETAIL) != 0) {
        p = Pattern.compile("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
        m = p.matcher(body);
        if (m.find()) {
            re |= DETAIL;
            thumb = Utils.unescapeXml(m.group(1));
            title = Utils.unescapeXml(m.group(2));
            title_jpn = Utils.unescapeXml(m.group(3));
            category = EhUtils.getCategory(m.group(4));
            uploader = m.group(5);
            posted = m.group(6);
            pages = Integer.parseInt(m.group(7));
            size = m.group(8);
            resized = m.group(9);
            parent = m.group(10);
            visible = m.group(11);
            language = m.group(12);
            people = Integer.parseInt(m.group(13).replace("String_Node_Str", "String_Node_Str"));
            Pattern pattern = Pattern.compile("String_Node_Str");
            Matcher matcher = pattern.matcher(m.group(14));
            if (matcher.find())
                rating = Float.parseFloat(matcher.group(1));
            else
                rating = Float.NaN;
            firstPage = m.group(15);
        }
    }
    if ((mode & TAG) != 0) {
        tags = new LinkedHashMap<String, LinkedList<String>>();
        p = Pattern.compile("String_Node_Str");
        m = p.matcher(body);
        while (m.find()) {
            re |= TAG;
            String groupName = m.group(1);
            LinkedList<String> group = getTagGroup(m.group(0));
            if (group != null) {
                tags.put(groupName, group);
            }
        }
    }
    if ((mode & PREVIEW_INFO) != 0) {
        p = Pattern.compile("String_Node_Str");
        m = p.matcher(body);
        if (m.find()) {
            re |= PREVIEW_INFO;
            previewSum = Integer.valueOf(m.group(1).replace("String_Node_Str", "String_Node_Str"));
        }
    }
    if ((mode & PREVIEW) != 0) {
        boolean isLargePreview = false;
        if (body.contains("String_Node_Str"))
            isLargePreview = true;
        if (isLargePreview) {
            previewList = new LargePreviewList();
            p = Pattern.compile("String_Node_Str");
            m = p.matcher(body);
            while (m.find()) {
                re |= PREVIEW;
                ((LargePreviewList) previewList).addItem(m.group(2), m.group(1));
            }
        } else {
            previewList = new NormalPreviewList();
            p = Pattern.compile("String_Node_Str");
            m = p.matcher(body);
            while (m.find()) {
                re |= PREVIEW;
                ((NormalPreviewList) previewList).addItem(m.group(3), m.group(4), "String_Node_Str", m.group(1), m.group(2), m.group(5));
            }
        }
        if (previewList != null)
            previewPerPage = previewList.size();
    }
    if ((mode & COMMENT) != 0) {
        p = Pattern.compile("String_Node_Str");
        m = p.matcher(body);
        comments = new LinkedList<Comment>();
        while (m.find()) {
            re |= COMMENT;
            comments.add(new Comment(m.group(1), m.group(2), m.group(3)));
        }
        Collections.sort(comments, cs);
    }
    return re;
}

Output:
     if ((mode & DETAIL) != 0) {
-        p = Pattern.compile("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
+        p = Pattern.compile("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
         m = p.matcher(body);


Input:
public void finalizeSaleOrder(SaleOrder saleOrder) throws Exception {
    saleOrder.setStatusSelect(ISaleOrder.STATUS_FINALIZE);
    saleOrderRepo.save(saleOrder);
    if (appSaleService.getAppSale().getManageSaleOrderVersion()) {
        this.saveSaleOrderPDFAsAttachment(saleOrder);
    }
    if (saleOrder.getVersionNumber() == 1) {
        saleOrder.setSaleOrderSeq(this.getSequence(saleOrder.getCompany()));
    }
}

Output:
 public void finalizeSaleOrder(SaleOrder saleOrder) throws Exception {
-    saleOrder.setStatusSelect(ISaleOrder.STATUS_FINALIZE);
-    saleOrderRepo.save(saleOrder);
-    if (appSaleService.getAppSale().getManageSaleOrderVersion()) {
-        this.saveSaleOrderPDFAsAttachment(saleOrder);
-    }
-    if (saleOrder.getVersionNumber() == 1) {
-        saleOrder.setSaleOrderSeq(this.getSequence(saleOrder.getCompany()));
-    }
+    _finalizeSaleOrder(saleOrder);
 }


Input:
private TypeAndOwner _resolveMethod(Class owner, String methodName, Type[] arguments) {
    Set handledSet = new HashSet();
    Stack previousClasses = _state.getPreviousClasses();
    int previousNum = previousClasses.size();
    Class oldOwner = owner;
    if (owner == null)
        owner = _state.getCurrentClass();
    do {
        Type type = _getMethodType(owner, methodName, arguments);
        if (type != null)
            return new TypeAndOwner(type, Type.createType(owner.getName()));
        handledSet.add(owner);
        owner = null;
        if (oldOwner == null)
            while (owner == null && previousNum > 0) {
                owner = (Class) previousClasses.get(--previousNum);
                if (handledSet.contains(owner))
                    owner = null;
            }
    } while (owner != null);
    return null;
}

Output:
             while (owner == null && previousNum > 0) {
-                owner = (Class) previousClasses.get(--previousNum);
-                if (handledSet.contains(owner))
-                    owner = null;
+                previousNum--;
+                Object previousObject = previousClasses.get(previousNum);
+                if (previousObject instanceof Class) {
+                    owner = (Class) previousObject;
+                    if (handledSet.contains(owner))
+                        owner = null;
+                }
             }


Input:
public void verifyParentID(ArrayList<SpreadSheetItemUtil> row_items, ArrayList<String> ver_errors, HashMap<String, String> htmlErrors, int sheetNumber, ResourceBundle resPageMsg, HashMap<String, ItemGroupBean> itemGroups) {
    int row_number = row_items.size();
    if (this.getItemName() != null && this.getItemName().equalsIgnoreCase(this.getParentItem())) {
        this.setParentItem("String_Node_Str");
    }
    if (!StringUtil.isBlank(this.getParentItem())) {
        SpreadSheetItemUtil cur_item = SpreadSheetItemUtil.isItemWithSameParameterExists(CrfTemplateColumnNameEnum.ITEM_NAME, this.getParentItem(), row_items);
        if (cur_item == null) {
            ver_errors.add(resPageMsg.getString("String_Node_Str") + row_number + resPageMsg.getString("String_Node_Str"));
            htmlErrors.put(sheetNumber + "String_Node_Str" + row_number + "String_Node_Str" + CrfTemplateColumnNameEnum.PARENT_ITEM.getCellNumber(), resPageMsg.getString("String_Node_Str"));
        }
        if (cur_item != null && cur_item.getParentItem() != null && cur_item.getParentItem().length() > 0) {
            ver_errors.add(resPageMsg.getString("String_Node_Str") + row_items.size() + resPageMsg.getString("String_Node_Str"));
            htmlErrors.put(sheetNumber + "String_Node_Str" + row_number + "String_Node_Str" + CrfTemplateColumnNameEnum.PARENT_ITEM.getCellNumber(), resPageMsg.getString("String_Node_Str"));
        }
        if (itemGroups != null && itemGroups.size() > 0) {
            ItemGroupBean item_group = itemGroups.get(this.getGroupLabel());
            if (item_group != null) {
                boolean isRepeatingGroup = item_group.getMeta().isRepeatingGroup();
                if (isRepeatingGroup) {
                    if (this.getGroupLabel() != null && this.getGroupLabel().length() > 0) {
                        ver_errors.add(resPageMsg.getString("String_Node_Str") + row_items.size() + resPageMsg.getString("String_Node_Str"));
                        htmlErrors.put(sheetNumber + "String_Node_Str" + row_number + "String_Node_Str" + CrfTemplateColumnNameEnum.PARENT_ITEM.getCellNumber(), resPageMsg.getString("String_Node_Str"));
                    }
                }
            }
        }
    }
}

Output:
     int row_number = row_items.size();
-    if (this.getItemName() != null && this.getItemName().equalsIgnoreCase(this.getParentItem())) {
+    if (this.getItemName().equalsIgnoreCase(this.getParentItem())) {
         this.setParentItem("String_Node_Str");


Input:
public void visit(NodeTraversal t, Node n, Node parent) {
    switch(n.getType()) {
        case Token.FUNCTION:
            Node grandparent = parent.getParent();
            if (grandparent == null || !isPrototypePropertyDeclaration(grandparent)) {
                visitFunctionLate(n, null);
            }
            break;
        case Token.NAME:
            {
                String name = n.getString();
                if (name == null || "String_Node_Str".equals(name) || parent.isFunction()) {
                    return;
                }
                if (parent.isVar() || parent.isCatch()) {
                    visitVar(n, parent);
                } else if (currentScope.isOuterVarEarly(name)) {
                    currentScope.addOuterVar(name);
                } else if (currentScope.getTypedef(name) != null || !name.equals(currentScope.getName()) && !currentScope.isDefinedLocally(name, false)) {
                }
                break;
            }
        case Token.GETPROP:
            if (parent.isExprResult() && n.isQualifiedName()) {
                visitPropertyDeclaration(n);
            }
            break;
        case Token.ASSIGN:
            {
                Node lvalue = n.getFirstChild();
                if (lvalue.isGetProp() && lvalue.isQualifiedName() && parent.isExprResult()) {
                    visitPropertyDeclaration(lvalue);
                }
                break;
            }
        case Token.CAST:
            castTypes.put(n, getDeclaredTypeOfNode(n.getJSDocInfo(), currentScope));
            break;
        case Token.OBJECTLIT:
            visitObjectLit(n, parent);
            break;
        case Token.CALL:
            visitCall(n);
            break;
    }
}

Output:
             if (grandparent == null || !isPrototypePropertyDeclaration(grandparent)) {
-                visitFunctionLate(n, null);
+                RawNominalType ownerType = maybeGetOwnerType(n, parent);
+                visitFunctionLate(n, ownerType);
             }


Input:
public void makeUniqueName(int namespaceId, DesignElement element) {
    if (element == null)
        return;
    String name = getUniqueName(namespaceId, element);
    if (name == null)
        return;
    NameSpace nameSpace = getCachedNameSpace(namespaceId);
    String validName = name;
    if (element instanceof StyleElement)
        validName = validName.toLowerCase();
    DesignElement cachedElement = nameSpace.getElement(validName);
    if (cachedElement == null) {
        element.setName(name.trim());
        nameSpace.insert(element);
    }
}

Output:
         return;
-    String name = getUniqueName(namespaceId, element);
+    String name = getUniqueName(namespaceId, element, prefix);
     if (name == null)


Input:
public void onClick(View v) {
    if (v.getId() == R.id.errorButton) {
        mMultiView.setViewState(MultiStateView.ViewState.LOADING);
        fetchNotifications();
        return;
    }
    ImgurNotification notification = mAdapter.getItem(mList.getChildAdapterPosition(v));
    if (notification.getType() == ImgurNotification.TYPE_MESSAGE) {
        ImgurConvo convo = new ImgurConvo(notification.getContentId(), notification.getAuthor(), 0);
        startActivity(ConvoThreadActivity.createIntent(getApplicationContext(), convo));
    } else {
        String url = "String_Node_Str" + notification.getContentId();
        Intent intent = ViewActivity.createIntent(getApplicationContext(), url, !TextUtils.isEmpty(notification.getAlbumCover()));
        startActivity(intent);
    }
}

Output:
     if (v.getId() == R.id.errorButton) {
-        mMultiView.setViewState(MultiStateView.ViewState.LOADING);
+        mMultiView.setViewState(MultiStateView.VIEW_STATE_LOADING);
         fetchNotifications();


Input:
private List<Query> readQueries() {
    List<HPCService.Query> qs = new ArrayList<HPCService.Query>();
    String queryFile = System.getProperty("String_Node_Str");
    if (!queryFile.startsWith("String_Node_Str")) {
        String currentPath = System.getProperty("String_Node_Str");
        queryFile = currentPath + (currentPath.endsWith("String_Node_Str") ? "String_Node_Str" : "String_Node_Str") + queryFile;
    }
    String queryContents = getContents(new File(queryFile));
    String[] vals = queryContents.split("String_Node_Str");
    for (int i = 0; i < vals.length; i += 3) {
        String name = vals[i].replaceAll("String_Node_Str", "String_Node_Str");
        String node = vals[i + 1];
        String script = vals[i + 2].replaceAll("String_Node_Str", "String_Node_Str");
        Query q = new Query(name, node, script);
        qs.add(q);
    }
    return qs;
}

Output:
         String name = vals[i].replaceAll("String_Node_Str", "String_Node_Str");
-        String node = vals[i + 1];
+        String node = vals[i + 1].equals("String_Node_Str") ? null : vals[i + 1];
         String script = vals[i + 2].replaceAll("String_Node_Str", "String_Node_Str");


Input:
public synchronized void setSkel(PlanSkeleton skel, Output output, SuperFace sf) {
    removeGeometryFor(sf);
    Node house;
    OnClick onclick = new OnClick() {
        public void selected(Output output, Node house2, SuperEdge se) {
            SkelGen.this.selected(skel, house2, sf, se);
        }
    };
    GreebleSkel greeble = new GreebleSkel(tweed);
    house = greeble.showSkeleton(output, onclick);
    gNode.attachChild(house);
    geometry.get(sf).set(house, output, skel);
    tweed.getRootNode().updateGeometricState();
    tweed.getRootNode().updateModelBound();
    tweed.gainFocus();
}

Output:
     GreebleSkel greeble = new GreebleSkel(tweed);
-    house = greeble.showSkeleton(output, onclick);
+    house = greeble.showSkeleton(skel.output, onclick, occluderLookup);
     gNode.attachChild(house);


Input:
public void addRow(int row, E value) {
    if (row <= getLastIndex()) {
        requested.addBlack(row, 1);
        TableItem item = new TableItem(table, 0, row);
        setItemText(item, value);
    } else {
        requested.addWhite(requested.size(), 1);
        table.setItemCount(table.getItemCount() + 1);
    }
}

Output:
         TableItem item = new TableItem(table, 0, row);
-        setItemText(item, value);
+        renderTableItem(item, value);
     } else {


Input:
private RecordSource compileJournal0(QueryModel model, JournalReaderFactory factory) throws ParserException {
    applyLimit(model);
    RecordMetadata metadata = model.getMetadata();
    JournalMetadata journalMetadata;
    if (metadata == null) {
        metadata = model.collectJournalMetadata(factory);
    }
    if (metadata instanceof JournalMetadata) {
        journalMetadata = (JournalMetadata) metadata;
    } else {
        throw QueryError.$(0, "String_Node_Str");
    }
    if (model.getAlias() != null) {
        journalMetadata.setAlias(model.getAlias().token);
    } else {
        journalMetadata.setAlias(QueryModel.stripMarker(model.getJournalName().token));
    }
    PartitionSource ps = new JournalPartitionSource(journalMetadata, true);
    RowSource rs = null;
    String latestByCol = null;
    RecordColumnMetadata latestByMetadata = null;
    ExprNode latestByNode = null;
    if (model.getLatestBy() != null) {
        latestByNode = model.getLatestBy();
        if (latestByNode.type != ExprNode.LITERAL) {
            throw QueryError.$(latestByNode.position, "String_Node_Str");
        }
        int colIndex = journalMetadata.getColumnIndexQuiet(latestByNode.token);
        if (colIndex == -1) {
            throw QueryError.invalidColumn(latestByNode.position, latestByNode.token);
        }
        latestByMetadata = journalMetadata.getColumnQuick(colIndex);
        int type = latestByMetadata.getType();
        if (type != ColumnType.SYMBOL && type != ColumnType.STRING && type != ColumnType.INT && type != ColumnType.LONG) {
            throw QueryError.position(latestByNode.position).$("String_Node_Str").$(ColumnType.nameOf(type)).$();
        }
        if (!latestByMetadata.isIndexed()) {
            throw QueryError.position(latestByNode.position).$("String_Node_Str").$();
        }
        latestByCol = latestByNode.token;
    }
    ExprNode where = model.getWhereClause();
    if (where != null) {
        IntrinsicModel im = queryFilterAnalyser.extract(where, journalMetadata, latestByCol, getTimestampIndexQuiet(model.getTimestamp(), journalMetadata));
        VirtualColumn filter = im.filter != null ? virtualColumnBuilder.createVirtualColumn(model, im.filter, journalMetadata) : null;
        if (filter != null) {
            if (filter.getType() != ColumnType.BOOLEAN) {
                throw QueryError.$(im.filter.position, "String_Node_Str");
            }
            if (filter.isConstant()) {
                if (filter.getBool(null)) {
                    filter = null;
                } else {
                    im.intrinsicValue = IntrinsicValue.FALSE;
                }
            }
        }
        if (im.intrinsicValue == IntrinsicValue.FALSE) {
            ps = new NoOpJournalPartitionSource(journalMetadata);
        } else {
            if (im.intervalHi < Long.MAX_VALUE || im.intervalLo > Long.MIN_VALUE) {
                ps = new MultiIntervalPartitionSource(ps, new SingleIntervalSource(new Interval(im.intervalLo, im.intervalHi)));
            }
            if (im.intervalSource != null) {
                ps = new MultiIntervalPartitionSource(ps, im.intervalSource);
            }
            if (latestByCol == null) {
                if (im.keyColumn != null) {
                    switch(journalMetadata.getColumn(im.keyColumn).getType()) {
                        case ColumnType.SYMBOL:
                            rs = buildRowSourceForSym(im);
                            break;
                        case ColumnType.STRING:
                            rs = buildRowSourceForStr(im);
                            break;
                        case ColumnType.INT:
                            rs = buildRowSourceForInt(im);
                            break;
                        case ColumnType.LONG:
                            rs = buildRowSourceForLong(im);
                            break;
                        default:
                            break;
                    }
                }
                if (filter != null) {
                    rs = new FilteredRowSource(rs == null ? new AllRowSource() : rs, filter);
                }
            } else {
                if (im.keyColumn != null && im.keyValuesIsLambda) {
                    int lambdaColIndex;
                    RecordSource lambda = compileSourceInternal(factory, im.keyValues.get(0));
                    RecordMetadata m = lambda.getMetadata();
                    switch(m.getColumnCount()) {
                        case 0:
                            Misc.free(lambda);
                            throw QueryError.$(im.keyValuePositions.getQuick(0), "String_Node_Str");
                        case 1:
                            lambdaColIndex = 0;
                            break;
                        default:
                            lambdaColIndex = m.getColumnIndexQuiet(latestByCol);
                            if (lambdaColIndex == -1) {
                                Misc.free(lambda);
                                throw QueryError.$(im.keyValuePositions.getQuick(0), "String_Node_Str");
                            }
                            break;
                    }
                    int lambdaColType = m.getColumn(lambdaColIndex).getType();
                    mutableSig.setParamCount(2).setName("String_Node_Str").paramType(0, latestByMetadata.getType(), true).paramType(1, lambdaColType, false);
                    LatestByLambdaRowSourceFactory fact = LAMBDA_ROW_SOURCE_FACTORIES.get(mutableSig);
                    if (fact != null) {
                        rs = fact.newInstance(latestByCol, lambda, lambdaColIndex, filter);
                    } else {
                        Misc.free(lambda);
                        throw QueryError.$(im.keyValuePositions.getQuick(0), "String_Node_Str");
                    }
                } else {
                    switch(latestByMetadata.getType()) {
                        case ColumnType.SYMBOL:
                            if (im.keyColumn != null) {
                                rs = new KvIndexSymListHeadRowSource(latestByCol, new CharSequenceHashSet(im.keyValues), filter);
                            } else {
                                rs = new KvIndexSymAllHeadRowSource(latestByCol, filter);
                            }
                            break;
                        case ColumnType.STRING:
                            if (im.keyColumn != null) {
                                rs = new KvIndexStrListHeadRowSource(latestByCol, new CharSequenceHashSet(im.keyValues), filter);
                            } else {
                                Misc.free(rs);
                                throw QueryError.$(latestByNode.position, "String_Node_Str");
                            }
                            break;
                        case ColumnType.LONG:
                            if (im.keyColumn != null) {
                                rs = new KvIndexLongListHeadRowSource(latestByCol, toLongHashSet(im), filter);
                            } else {
                                Misc.free(rs);
                                throw QueryError.$(latestByNode.position, "String_Node_Str");
                            }
                            break;
                        case ColumnType.INT:
                            if (im.keyColumn != null) {
                                rs = new KvIndexIntListHeadRowSource(latestByCol, toIntHashSet(im), filter);
                            } else {
                                Misc.free(rs);
                                throw QueryError.$(latestByNode.position, "String_Node_Str");
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
        }
    } else if (latestByCol != null) {
        switch(latestByMetadata.getType()) {
            case ColumnType.SYMBOL:
                rs = new KvIndexSymAllHeadRowSource(latestByCol, null);
                break;
            default:
                Misc.free(rs);
                throw QueryError.$(latestByNode.position, "String_Node_Str");
        }
    }
    if (rs == null && model.getColumns().size() == 1) {
        QueryColumn qc = model.getColumns().getQuick(0);
        if ("String_Node_Str".equals(qc.getAst().token) && qc.getAst().paramCount == 0) {
            model.getOrderBy().clear();
            model.getColumns().clear();
            return new CountRecordSource(qc.getAlias() == null ? "String_Node_Str" : qc.getAlias(), ps);
        }
    }
    RecordSource recordSource = new JournalRecordSource(ps, rs == null ? new AllRowSource() : rs);
    if (QueryModel.hasMarker(model.getJournalName().token)) {
        return new NoRowIdRecordSource().of(recordSource);
    }
    return recordSource;
}

Output:
         }
-        int colIndex = journalMetadata.getColumnIndexQuiet(latestByNode.token);
+        latestByCol = model.translateAlias(latestByNode.token).toString();
+        int colIndex = journalMetadata.getColumnIndexQuiet(latestByCol);
         if (colIndex == -1) {


Input:
private static void printHelpText(Options options) {
    HelpFormatter formatter = new HelpFormatter();
    formatter.printHelp("String_Node_Str", options);
}

Output:
     HelpFormatter formatter = new HelpFormatter();
-    formatter.printHelp("String_Node_Str", options);
+    String header = "String_Node_Str" + "String_Node_Str";
+    CliCommand[] commands = { new CliValidateCommand(), new CliPlayCommand() };
+    for (CliCommand command : commands) {
+        header += String.format("String_Node_Str", command.getCommandName(), command.getHelpTextDescription());
+    }
+    header += "String_Node_Str";
+    formatter.printHelp("String_Node_Str", header, options, "String_Node_Str");
 }


Input:
public void testEval() throws Exception {
    PrecisionRecallEvaluator evaluator = new PrecisionRecallEvaluator();
    MyrrixIRStatistics stats = (MyrrixIRStatistics) evaluator.evaluate(new File("String_Node_Str"));
    log.info(stats.toString());
}

Output:
 public void testEval() throws Exception {
-    PrecisionRecallEvaluator evaluator = new PrecisionRecallEvaluator();
-    MyrrixIRStatistics stats = (MyrrixIRStatistics) evaluator.evaluate(new File("String_Node_Str"));
-    log.info(stats.toString());
+    MyrrixIRStatistics stats = (MyrrixIRStatistics) new PrecisionRecallEvaluator().evaluate(new File("String_Node_Str"));
+    log.info(String.valueOf(stats));
 }


Input:
private SoyExpression invokeMaxFunction(SoyExpression left, SoyExpression right) {
    if (left.assignableToNullableInt() && right.assignableToNullableInt()) {
        return SoyExpression.forInt(MATH_MAX_LONG.invoke(left.unboxAs(long.class), right.unboxAs(long.class)));
    } else if (left.assignableToNullableFloat() && right.assignableToNullableFloat()) {
        return SoyExpression.forInt(MATH_MAX_DOUBLE.invoke(left.unboxAs(double.class), right.unboxAs(double.class)));
    } else {
        return SoyExpression.forSoyValue(NUMBER_TYPE, MAX_FN.invoke(left.box(), right.box()));
    }
}

Output:
     } else if (left.assignableToNullableFloat() && right.assignableToNullableFloat()) {
-        return SoyExpression.forInt(MATH_MAX_DOUBLE.invoke(left.unboxAs(double.class), right.unboxAs(double.class)));
+        return SoyExpression.forFloat(MATH_MAX_DOUBLE.invoke(left.unboxAs(double.class), right.unboxAs(double.class)));
     } else {


Input:
public synchronized CharBucket nextBucket() {
    try {
        if (finished) {
            return end;
        }
        if (currentBucket != null) {
            instances.release(currentBucket);
        }
        Object element = buckets.take();
        if (element == end) {
            finished = true;
            return end;
        } else {
            currentBucket = (Entry<CharBucket>) element;
        }
        return currentBucket.get();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        finished = true;
        return end;
    }
}

Output:
         if (finished) {
-            return end;
+            if (buckets.size() <= 1) {
+                return end;
+            }
         }


Input:
public void draw(int startX, int startY) {
    if (getIcon() != null) {
        if (!isActive) {
            GL11.glColor4f(0.2f, 0.2f, 0.2f, 0.2f);
        } else {
            GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
        }
        Proxies.render.bindTexture(TextureMap.locationBlocksTexture);
        manager.gui.drawTexturedModalRect(startX + xPos, startY + yPos, getIcon(), 16, 16);
    }
}

Output:
         if (!isActive) {
-            GL11.glColor4f(0.2f, 0.2f, 0.2f, 0.2f);
+            GlStateManager.color(0.2f, 0.2f, 0.2f, 0.2f);
         } else {


Input:
protected Void copyVolumeFromPrimaryToImageCallback(AsyncCallbackDispatcher<VolumeServiceImpl, CopyCommandResult> callback, CopyVolumeContext<VolumeApiResult> context) {
    VolumeInfo srcVolume = context.srcVolume;
    VolumeInfo destVolume = context.destVolume;
    CopyCommandResult result = callback.getResult();
    AsyncCallFuture<VolumeApiResult> future = context.future;
    VolumeApiResult res = new VolumeApiResult(destVolume);
    try {
        if (res.isFailed()) {
            destVolume.processEvent(Event.OperationFailed);
            srcVolume.processEvent(Event.OperationFailed);
            res.setResult(result.getResult());
            future.complete(res);
        } else {
            srcVolume.processEvent(Event.OperationSuccessed);
            destVolume.processEvent(Event.OperationSuccessed, result.getAnswer());
            future.complete(res);
        }
    } catch (Exception e) {
        res.setResult(e.toString());
        future.complete(res);
    }
    return null;
}

Output:
             srcVolume.processEvent(Event.OperationSuccessed);
-            destVolume.processEvent(Event.OperationSuccessed, result.getAnswer());
+            destVolume.processEventOnly(Event.OperationSuccessed, result.getAnswer());
             future.complete(res);


Input:
public void setUp() {
    factory = new ChangeFactory();
}

Output:
 public void setUp() {
-    factory = new ChangeFactory();
+    factory = ChangeFactory.getInstance();
 }


Input:
public static Set<DecisionOption> getDecisionOptions(String decisionOptions) {
    Set<DecisionOption> decOptions = new HashSet<DecisionOption>();
    for (String decsionOpt : decisionOptions.split("String_Node_Str")) {
        DecisionOption state = new DecisionOption();
        Result result = state.setFromXml(decsionOpt);
        if (result.isFalse()) {
            OseeLog.log(Activator.class, Level.SEVERE, result.getText());
        } else {
            decOptions.add(state);
        }
    }
    return decOptions;
}

Output:
 public static Set<DecisionOption> getDecisionOptions(String decisionOptions) {
-    Set<DecisionOption> decOptions = new HashSet<DecisionOption>();
+    Set<DecisionOption> decOptions = new LinkedHashSet<DecisionOption>();
     for (String decsionOpt : decisionOptions.split("String_Node_Str")) {


Input:
protected int run(CmdLineParser parser) {
    final List<String> args = parser.getRemainingArgs();
    if (args.isEmpty()) {
        System.err.println("String_Node_Str");
        return 3;
    }
    if (args.size() > 2) {
        System.err.printf("String_Node_Str", args.size());
        return 3;
    }
    final SAMFileReader.ValidationStringency stringency = Utils.toStringency(parser.getOptionValue(stringencyOpt), "String_Node_Str");
    if (stringency == null)
        return 3;
    final String path = args.get(0);
    final String out = args.size() > 1 ? args.get(1) : path + "String_Node_Str";
    final SAMFileReader reader;
    try {
        reader = new SAMFileReader(WrapSeekable.openPath(getConf(), new Path(path)), false);
    } catch (Exception e) {
        System.err.printf("String_Node_Str", path, e.getMessage());
        return 4;
    }
    final SAMFileHeader header;
    try {
        header = reader.getFileHeader();
    } catch (SAMFormatException e) {
        System.err.printf("String_Node_Str", path, e.getMessage());
        return 6;
    }
    final BAMIndexer indexer;
    try {
        final Path p = new Path(out);
        indexer = new BAMIndexer(p.getFileSystem(getConf()).create(p), header);
    } catch (Exception e) {
        System.err.printf("String_Node_Str", out, e.getMessage());
        return 5;
    }
    reader.enableFileSource(true);
    final SAMRecordIterator it = reader.iterator();
    try {
        while (it.hasNext()) indexer.processAlignment(it.next());
    } catch (SAMFormatException e) {
        System.err.printf("String_Node_Str", path, e.getMessage());
        return 6;
    }
    indexer.finish();
    return 0;
}

Output:
     }
-    final SAMFileReader.ValidationStringency stringency = Utils.toStringency(parser.getOptionValue(stringencyOpt), "String_Node_Str");
+    final SAMFileReader.ValidationStringency stringency = Utils.toStringency(parser.getOptionValue(stringencyOpt, SAMFileReader.ValidationStringency.DEFAULT_STRINGENCY.toString()), "String_Node_Str");
     if (stringency == null)


Input:
private boolean sendBroadcast(Resource updatedResource) {
    return LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(ACTION_RESOURCE_MODIFIED).putExtra("String_Node_Str", updatedResource));
}

Output:
 private boolean sendBroadcast(Resource updatedResource) {
-    return LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(ACTION_RESOURCE_MODIFIED).putExtra("String_Node_Str", updatedResource));
+    if (updatedResource != null) {
+        return LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(ACTION_RESOURCE_MODIFIED).putExtra("String_Node_Str", updatedResource));
+    }
+    return false;
 }


Input:
public Object[] getChildren(Object parentElement) {
    if (fileProvider == null) {
        return new Object[] { IFileProvider.INVALID_FILESYSTEM };
    }
    if (parentElement instanceof LocalFileSystem) {
        return fileProvider.getRoots();
    } else {
        try {
            File parent;
            if (parentElement instanceof File) {
                parent = (File) parentElement;
            } else {
                parent = new File(parentElement.toString());
            }
            return fileProvider.getChildren(parent, directoryFilter);
        } catch (Exception e) {
            return new Object[] { "String_Node_Str" };
        }
    }
}

Output:
 public Object[] getChildren(Object parentElement) {
-    if (fileProvider == null) {
-        return new Object[] { IFileProvider.INVALID_FILESYSTEM };
-    }
-    if (parentElement instanceof LocalFileSystem) {
-        return fileProvider.getRoots();
-    } else {
-        try {
+    try {
+        if (fileProvider == null) {
+            return new Object[] { IFileProvider.INVALID_FILESYSTEM };
+        }
+        if (parentElement instanceof LocalFileSystem) {
+            return fileProvider.getRoots();
+        } else {
             File parent;


Input:
public void onPlayerJoin(final PlayerJoinEvent event) {
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    final Player player = event.getPlayer();
    final UUID playerUUID = player.getUniqueId();
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    if (playerUUID == null) {
        plugin.getLogger().severe("String_Node_Str" + player.getName() + "String_Node_Str");
        return;
    }
    if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        String language = getLanguage(player);
        if (plugin.getResource("String_Node_Str" + language + "String_Node_Str") != null) {
            if (DEBUG)
                plugin.getLogger().info("String_Node_Str");
            if (plugin.getPlayers().getLocale(playerUUID).isEmpty()) {
                if (DEBUG)
                    plugin.getLogger().info("String_Node_Str" + language);
                plugin.getPlayers().setLocale(playerUUID, language);
            }
        }
    } else {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
    }
    if (player.isOp() && plugin.getUpdateCheck() != null) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        plugin.checkUpdatesNotify(player);
    }
    if (players == null) {
        plugin.getLogger().severe("String_Node_Str");
    }
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    if (!players.hasIsland(playerUUID) && !players.inTeam(playerUUID)) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        return;
    }
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    UUID leader = null;
    Location loc = null;
    if (players.inTeam(playerUUID) && players.getTeamIslandLocation(playerUUID) == null) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        leader = players.getTeamLeader(playerUUID);
        players.setTeamIslandLocation(playerUUID, players.getIslandLocation(leader));
    }
    if (players.inTeam(playerUUID) && players.getTeamLeader(playerUUID).equals(playerUUID)) {
        Iterator<UUID> it = players.getMembers(playerUUID).iterator();
        while (it.hasNext()) {
            UUID member = it.next();
            if (!players.getTeamLeader(member).equals(playerUUID)) {
                plugin.getLogger().warning(plugin.getPlayers().getName(member) + "String_Node_Str");
                plugin.getLogger().warning("String_Node_Str" + player.getName() + "String_Node_Str" + plugin.getPlayers().getName(players.getTeamLeader(member)));
                players.removeMember(players.getTeamLeader(member), member);
            }
        }
    }
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    if (players.hasIsland(playerUUID)) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        loc = players.getIslandLocation(playerUUID);
        leader = playerUUID;
    } else if (players.inTeam(playerUUID)) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        loc = players.getTeamIslandLocation(playerUUID);
        leader = players.getTeamLeader(playerUUID);
        if (leader == null) {
            plugin.getLogger().severe("String_Node_Str" + player.getName() + "String_Node_Str");
            players.setLeaveTeam(playerUUID);
        }
    }
    if (loc != null && leader != null) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        Island island = plugin.getGrid().getIslandAt(loc);
        if (island == null) {
            if (DEBUG)
                plugin.getLogger().info("String_Node_Str");
            Island islandByOwner = plugin.getGrid().getIsland(leader);
            if (islandByOwner == null) {
                if (plugin.getGrid().onGrid(loc)) {
                    plugin.getGrid().addIsland(loc.getBlockX(), loc.getBlockZ(), leader);
                } else {
                    plugin.getLogger().severe(player.getName() + "String_Node_Str" + loc + "String_Node_Str");
                }
            } else {
                if (DEBUG)
                    plugin.getLogger().info("String_Node_Str");
                plugin.getLogger().warning(player.getName() + "String_Node_Str");
                plugin.getGrid().deleteIslandOwner(playerUUID);
                if (plugin.getGrid().onGrid(loc)) {
                    plugin.getGrid().addIsland(loc.getBlockX(), loc.getBlockZ(), leader);
                } else {
                    plugin.getLogger().severe(player.getName() + "String_Node_Str" + loc + "String_Node_Str");
                }
            }
        } else {
            if (DEBUG)
                plugin.getLogger().info("String_Node_Str");
            Island islandByOwner = plugin.getGrid().getIsland(leader);
            if (islandByOwner == null) {
                plugin.getLogger().warning(player.getName() + "String_Node_Str");
                plugin.getGrid().setIslandOwner(island, leader);
            } else {
                if (DEBUG)
                    plugin.getLogger().info("String_Node_Str");
                if (!islandByOwner.equals(island)) {
                    if (DEBUG)
                        plugin.getLogger().info("String_Node_Str");
                    plugin.getLogger().warning(player.getName() + "String_Node_Str");
                    plugin.getGrid().deleteIsland(islandByOwner.getCenter());
                    plugin.getGrid().setIslandOwner(island, leader);
                } else {
                    if (island.getOwner().equals(player.getUniqueId())) {
                        if (DEBUG) {
                            plugin.getLogger().info("String_Node_Str" + islandByOwner.getProtectionSize());
                            plugin.getLogger().info("String_Node_Str");
                        }
                        boolean hasARangePerm = false;
                        int range = Settings.islandProtectionRange;
                        if (island.getProtectionSize() == 0) {
                            plugin.getLogger().warning("String_Node_Str" + player.getName() + "String_Node_Str" + range);
                            island.setProtectionSize(range);
                        }
                        for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
                            if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
                                if (DEBUG)
                                    plugin.getLogger().info("String_Node_Str");
                                if (perms.getPermission().contains(Settings.PERMPREFIX + "String_Node_Str")) {
                                    break;
                                } else {
                                    String[] spl = perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str");
                                    if (spl.length > 1) {
                                        if (!NumberUtils.isDigits(spl[1])) {
                                            plugin.getLogger().severe("String_Node_Str" + player.getName() + "String_Node_Str" + perms.getPermission() + "String_Node_Str");
                                        } else {
                                            if (DEBUG)
                                                plugin.getLogger().info("String_Node_Str");
                                            hasARangePerm = true;
                                            range = Math.max(range, Integer.valueOf(spl[1]));
                                            if (DEBUG)
                                                plugin.getLogger().info("String_Node_Str" + range);
                                        }
                                    }
                                }
                            }
                        }
                        if (hasARangePerm) {
                            if (range % 2 != 0) {
                                range--;
                                if (DEBUG)
                                    plugin.getLogger().warning("String_Node_Str" + range + "String_Node_Str" + player.getName());
                            }
                            if (DEBUG)
                                plugin.getLogger().info("String_Node_Str" + range + "String_Node_Str" + islandByOwner.getProtectionSize());
                            if (range != islandByOwner.getProtectionSize()) {
                                plugin.getMessages().storeMessage(playerUUID, plugin.myLocale(playerUUID).adminSetRangeUpdated.replace("String_Node_Str", String.valueOf(range)));
                                plugin.getLogger().info("String_Node_Str" + islandByOwner.getProtectionSize() + "String_Node_Str" + range + "String_Node_Str" + player.getName() + "String_Node_Str");
                            }
                            islandByOwner.setProtectionSize(range);
                        }
                    }
                }
            }
        }
    }
    if (Settings.loginLevel) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        new LevelCalcByChunk(plugin, playerUUID, player, false);
    }
    if (Settings.resetLimit < players.getResetsLeft(playerUUID) || (Settings.resetLimit >= 0 && players.getResetsLeft(playerUUID) < 0)) {
        players.setResetsLeft(playerUUID, Settings.resetLimit);
    }
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    if (!player.getName().isEmpty()) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str" + player.getName());
        players.setPlayerName(playerUUID, player.getName());
    } else {
        plugin.getLogger().warning("String_Node_Str" + playerUUID.toString());
    }
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    players.save(playerUUID);
    if (Settings.logInRemoveMobs) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        plugin.getGrid().removeMobs(player.getLocation());
    }
    if (Settings.setTeamName) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        Scoreboards.getInstance().setLevel(playerUUID);
    }
    Island currentIsland = plugin.getGrid().getIslandAt(player.getLocation());
    if (currentIsland != null && (currentIsland.isLocked() || plugin.getPlayers().isBanned(currentIsland.getOwner(), player.getUniqueId()))) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        if (!currentIsland.getMembers().contains(playerUUID) && !player.isOp() && !VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
            if (DEBUG)
                plugin.getLogger().info("String_Node_Str");
            Util.sendMessage(player, ChatColor.RED + plugin.myLocale(playerUUID).lockIslandLocked);
            plugin.getGrid().homeTeleport(player);
        }
    }
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    plugin.getChatListener().setPlayerLevel(playerUUID, plugin.getPlayers().getIslandLevel(player.getUniqueId()));
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    if (!player.hasPermission(Settings.PERMPREFIX + "String_Node_Str")) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        TopTen.topTenRemoveEntry(playerUUID);
    }
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str" + player.getName());
    final List<String> messages = plugin.getMessages().getMessages(playerUUID);
    if (messages != null) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        plugin.getServer().getScheduler().runTaskLater(plugin, new Runnable() {
            public void run() {
                Util.sendMessage(player, ChatColor.AQUA + plugin.myLocale(playerUUID).newsHeadline);
                int i = 1;
                for (String message : messages) {
                    Util.sendMessage(player, i++ + "String_Node_Str" + message);
                }
                plugin.getMessages().clearMessages(playerUUID);
            }
        }, 40L);
    }
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
}

Output:
             UUID member = it.next();
-            if (!players.getTeamLeader(member).equals(playerUUID)) {
+            if (players.getTeamLeader(member) != null && !players.getTeamLeader(member).equals(playerUUID)) {
                 plugin.getLogger().warning(plugin.getPlayers().getName(member) + "String_Node_Str");