Input:
private boolean setBounds(Rect bounds) {
    boolean oldFullscreen = mFullscreen;
    if (mDisplayContent != null) {
        mDisplayContent.getLogicalDisplayRect(mTmpRect);
        if (bounds == null) {
            bounds = mTmpRect;
            mFullscreen = true;
        } else {
            if (!bounds.intersect(mTmpRect)) {
                return false;
            }
            mFullscreen = mTmpRect.equals(bounds);
        }
    }
    if (bounds == null) {
        return false;
    }
    if (mBounds.equals(bounds) && oldFullscreen == mFullscreen) {
        return false;
    }
    mAnimationBackgroundSurface.setBounds(bounds);
    mBounds.set(bounds);
    return true;
}

Output:
     }
-    if (mBounds.equals(bounds) && oldFullscreen == mFullscreen) {
+    if (mBounds.equals(bounds) && oldFullscreen == mFullscreen && mRotation == rotation) {
         return false;


Input:
public static org.hl7.fhir.dstu2016may.model.Identifier convertIdentifier(org.hl7.fhir.dstu3.model.Identifier src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2016may.model.Identifier tgt = new org.hl7.fhir.dstu2016may.model.Identifier();
    copyElement(src, tgt);
    tgt.setUse(convertIdentifierUse(src.getUse()));
    tgt.setType(convertCodeableConcept(src.getType()));
    tgt.setSystem(src.getSystem());
    tgt.setValue(src.getValue());
    tgt.setPeriod(convertPeriod(src.getPeriod()));
    tgt.setAssigner(convertReference(src.getAssigner()));
    return tgt;
}

Output:
 public static org.hl7.fhir.dstu2016may.model.Identifier convertIdentifier(org.hl7.fhir.dstu3.model.Identifier src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
protected void setDefaultRenderProperties(ISupportOnRenderCallback display) {
    IScriptRenderMethods scriptable = null;
    if (display instanceof IScriptableProvider) {
        scriptable = (IScriptRenderMethods) ((IScriptableProvider) display).getScriptObject();
    } else {
        scriptable = (IScriptRenderMethods) display;
    }
    scriptable.js_setBgcolor(PersistHelper.createColorString(renderDefaultBgColor));
    if (renderDefaultBorder != null)
        scriptable.js_setBorder(ComponentFactoryHelper.createBorderString(renderDefaultBorder));
    scriptable.js_setEnabled(renderDefaultEnabled);
    scriptable.js_setFgcolor(PersistHelper.createColorString(renderDefaultFgColor));
    scriptable.js_setFont(PersistHelper.createFontString(renderDefaultFont));
    scriptable.js_setToolTipText(renderDefaultTooltipText);
    if (isUseDefaultTransparent())
        scriptable.js_setTransparent(!renderDefaultOpaque);
    scriptable.js_setVisible(renderDefaultVisible);
}

Output:
     }
-    scriptable.js_setBgcolor(PersistHelper.createColorString(renderDefaultBgColor));
+    if (isUseDefaultBackground())
+        scriptable.js_setBgcolor(PersistHelper.createColorString(renderDefaultBgColor));
     if (renderDefaultBorder != null)


Input:
private void createStruts() {
    int i = 0;
    for (final WB_FrameStrut strut : frame.getStruts()) {
        final int offsets = i * 2;
        final int offsete = (i * 2) + 1;
        int ns = (int) Math.round(strut.getLength() / maximumStrutLength);
        ns = Math.max(ns, 1);
        final ArrayList<HE_Halfedge> hes = new ArrayList<HE_Halfedge>();
        final HE_Vertex[][] extraVertices = new HE_Vertex[strutFacets][ns - 1];
        for (int j = 0; j < strutFacets; j++) {
            for (int k = 0; k < (ns - 1); k++) {
                extraVertices[j][k] = new HE_Vertex(gf.createInterpolatedPoint(strutNodeConnections[offsets].vertices.get(j), strutNodeConnections[offsete].vertices.get(j), (k + 1) / (double) ns));
                mesh.add(extraVertices[j][k]);
            }
        }
        for (int j = 0; j < strutFacets; j++) {
            final int jp = (j + 1) % strutFacets;
            final HE_Vertex s0 = strutNodeConnections[offsets].vertices.get(j);
            final HE_Vertex s1 = strutNodeConnections[offsets].vertices.get(jp);
            final HE_Vertex e2 = strutNodeConnections[offsete].vertices.get(jp);
            final HE_Vertex e3 = strutNodeConnections[offsete].vertices.get(j);
            for (int k = 0; k < ns; k++) {
                final HE_Face f = new HE_Face();
                final HE_Halfedge he0 = new HE_Halfedge();
                final HE_Halfedge he1 = new HE_Halfedge();
                final HE_Halfedge he2 = new HE_Halfedge();
                final HE_Halfedge he3 = new HE_Halfedge();
                mesh.setVertex(he0, (k == 0) ? s0 : extraVertices[j][k - 1]);
                mesh.setVertex(he1, (k == 0) ? s1 : extraVertices[jp][k - 1]);
                mesh.setVertex(he2, (k == (ns - 1)) ? e2 : extraVertices[jp][k]);
                mesh.setVertex(he3, (k == (ns - 1)) ? e3 : extraVertices[j][k]);
                mesh.setNext(he0, he1);
                mesh.setNext(he1, he2);
                mesh.setNext(he2, he3);
                mesh.setNext(he3, he0);
                mesh.setFace(he0, f);
                mesh.setHalfedge(f, he0);
                f.setTemporaryLabel(1);
                mesh.setFace(he1, f);
                mesh.setFace(he2, f);
                mesh.setFace(he3, f);
                mesh.setHalfedge(he0.getVertex(), he0);
                mesh.setHalfedge(he1.getVertex(), he1);
                mesh.setHalfedge(he2.getVertex(), he2);
                mesh.setHalfedge(he3.getVertex(), he3);
                mesh.add(f);
                mesh.add(he0);
                mesh.add(he1);
                mesh.add(he2);
                mesh.add(he3);
                hes.add(he1);
                hes.add(he3);
                if ((k < (ns - 1)) && (k > 0)) {
                    hes.add(he0);
                    hes.add(he2);
                }
            }
        }
        i++;
    }
}

Output:
                 mesh.setHalfedge(f, he0);
-                f.setTemporaryLabel(1);
+                f.setInternalLabel(1);
                 mesh.setFace(he1, f);


Input:
private void initializeProcess(Path terminalPath) throws Exception {
    String os = System.getProperty("String_Node_Str").toLowerCase();
    String[] commands;
    if (os.contains("String_Node_Str")) {
        commands = editorConfigBean.getTerminalWinCommand().split("String_Node_Str");
    } else {
        commands = editorConfigBean.getTerminalNixCommand().split("String_Node_Str");
    }
    ProcessBuilder processBuilder = new ProcessBuilder(commands);
    processBuilder.redirectError(ProcessBuilder.Redirect.PIPE);
    processBuilder.redirectInput(ProcessBuilder.Redirect.PIPE);
    processBuilder.redirectOutput(ProcessBuilder.Redirect.PIPE);
    processBuilder.directory(directoryService.workingDirectory().toFile());
    Optional.ofNullable(terminalPath).filter(Files::exists).map(Path::toFile).ifPresent(processBuilder::directory);
    this.process = processBuilder.start();
    Charset charset = Charset.forName(editorConfigBean.getTerminalCharset());
    this.inputStream = process.getInputStream();
    this.inputStreamReader = new InputStreamReader(inputStream, charset);
    this.inputReader = new BufferedReader(inputStreamReader);
    this.errorStream = process.getErrorStream();
    this.errorStreamReader = new InputStreamReader(errorStream, charset);
    this.errorReader = new BufferedReader(errorStreamReader);
    this.outputStream = process.getOutputStream();
    this.outputStreamWriter = new OutputStreamWriter(outputStream, charset);
    this.outputWriter = new BufferedWriter(outputStreamWriter);
    threadService.start(() -> {
        inputReader.lines().forEach(this::print);
    });
    threadService.start(() -> {
        errorReader.lines().forEach(this::print);
    });
    focusCommandInput();
    process.waitFor();
}

Output:
     String[] commands;
-    if (os.contains("String_Node_Str")) {
+    if (OSHelper.isWindows()) {
         commands = editorConfigBean.getTerminalWinCommand().split("String_Node_Str");


Input:
public void execute() {
    execute(new Object());
}

Output:
 public void execute() {
-    execute(new Object());
+    if (listener != null)
+        listener.onStart(this);
+    start();
 }


Input:
public void checkExtends(DesignElement parent) throws ExtendsException {
    super.checkExtends(parent);
    if (provider != null)
        provider.checkExtends(parent);
    else {
        OdaDataSet odaParent = (OdaDataSet) parent;
        if (odaParent.extensionID != null && !odaParent.extensionID.equals(extensionID))
            throw new WrongTypeException(this, parent, WrongTypeException.DESIGN_EXCEPTION_WRONG_EXTENSION_TYPE);
        if (extensionID != null && !extensionID.equals(odaParent.extensionID))
            throw new WrongTypeException(this, parent, WrongTypeException.DESIGN_EXCEPTION_WRONG_EXTENSION_TYPE);
    }
}

Output:
     super.checkExtends(parent);
-    if (provider != null)
+    if (provider != null && !(provider instanceof OdaDummyProvider))
         provider.checkExtends(parent);


Input:
protected UGIWithPrincipal createUGI(ImpersonationRequest impersonationRequest) throws IOException {
    ImpersonationRequest jsonRequest = new ImpersonationRequest(impersonationRequest.getEntityId(), impersonationRequest.getImpersonatedOpType(), impersonationRequest.getPrincipal());
    PrincipalCredentials principalCredentials = GSON.fromJson(executeRequest(jsonRequest).getResponseBodyAsString(), PrincipalCredentials.class);
    LOG.debug("String_Node_Str", principalCredentials);
    Location location = locationFactory.create(URI.create(principalCredentials.getCredentialsPath()));
    try {
        UserGroupInformation impersonatedUGI = UserGroupInformation.createRemoteUser(principalCredentials.getPrincipal());
        impersonatedUGI.addCredentials(readCredentials(location));
        return new UGIWithPrincipal(principalCredentials.getPrincipal(), impersonatedUGI);
    } finally {
        try {
            if (!location.delete()) {
                LOG.warn("String_Node_Str", location);
            }
        } catch (IOException e) {
            LOG.warn("String_Node_Str", location, e);
        }
    }
}

Output:
     try {
-        UserGroupInformation impersonatedUGI = UserGroupInformation.createRemoteUser(principalCredentials.getPrincipal());
+        String user = principalCredentials.getPrincipal();
+        if (impersonationRequest.getImpersonatedOpType() == ImpersonatedOpType.EXPLORE) {
+            user = new KerberosName(user).getShortName();
+        }
+        UserGroupInformation impersonatedUGI = UserGroupInformation.createRemoteUser(user);
         impersonatedUGI.addCredentials(readCredentials(location));


Input:
public void marshallEntity(Object object, MediaType mediaType, OutputStream output, boolean sendRelationships) throws JAXBException {
    if (sendRelationships) {
        preMarshallEntity(object);
    }
    Marshaller marshaller = getJAXBContext().createMarshaller();
    marshaller.setProperty(MarshallerProperties.MEDIA_TYPE, mediaType.toString());
    marshaller.setProperty(MarshallerProperties.JSON_INCLUDE_ROOT, false);
    marshaller.setAdapter(new LinkAdapter(getBaseURI().toString(), this));
    marshaller.setAdapter(new RelationshipLinkAdapter(getBaseURI().toString(), this));
    try {
        for (XmlAdapter adapter : getAdapters()) {
            marshaller.setAdapter(adapter);
        }
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
    if (mediaType == MediaType.APPLICATION_XML_TYPE && object instanceof List) {
        marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
        XMLOutputFactory outputFactory = XMLOutputFactory.newFactory();
        XMLStreamWriter writer = null;
        try {
            writer = outputFactory.createXMLStreamWriter(output);
            writer.writeStartDocument();
            writer.writeStartElement("String_Node_Str");
            for (Object o : (List<Object>) object) {
                marshaller.marshal(o, writer);
            }
            writer.writeEndDocument();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            postMarshallEntity(object);
        }
    } else {
        marshaller.marshal(object, output);
        postMarshallEntity(object);
    }
}

Output:
     marshaller.setAdapter(new RelationshipLinkAdapter(getBaseURI().toString(), this));
-    try {
-        for (XmlAdapter adapter : getAdapters()) {
-            marshaller.setAdapter(adapter);
-        }
-    } catch (Exception e) {
-        e.printStackTrace();
-        throw new RuntimeException(e);
+    for (XmlAdapter adapter : getAdapters()) {
+        marshaller.setAdapter(adapter);
     }


Input:
public void testEven4Parity() {
    final int LOWER_SUCCESS = 40;
    final int UPPER_SUCCESS = 50;
    final EvenParity model = new EvenParity(getEvolver(), 4);
    setupModel(model);
    final int noSuccess = getNoSuccesses(model);
    assertBetween("String_Node_Str", LOWER_SUCCESS, UPPER_SUCCESS, noSuccess);
}

Output:
     setupModel(model);
-    final int noSuccess = getNoSuccesses(model);
+    final int noSuccess = getNoSuccesses(model, false, false);
     assertBetween("String_Node_Str", LOWER_SUCCESS, UPPER_SUCCESS, noSuccess);


Input:
private void verifyAssignments() throws ExecutionFailureException {
    while (this.vertexPrioQueue.size() > 0) {
        QueueElem topElem = this.vertexPrioQueue.poll();
        if (topElem.getNoAssignedSplits() == 0) {
            throw new ExecutionFailureException("String_Node_Str" + topElem.getVertex().getName() + "String_Node_Str" + topElem.getVertex().getAllocatedResource().getInstance().getInstanceConnectionInfo().getHostName() + "String_Node_Str" + topElem.getVertex().getID() + "String_Node_Str");
        }
        LOG.info(topElem.getNoAssignedSplits() + "String_Node_Str" + topElem.getVertex().getAllocatedResource().getInstance().getInstanceConnectionInfo().getHostName());
        for (InputSplit is : topElem.getVertex().getEnvironment().getInputSplits()) {
            LOG.info("String_Node_Str" + ((FileInputSplit) is).getPath());
            for (String hn : is.getHostNames()) {
                LOG.info("String_Node_Str" + hn);
            }
        }
    }
}

Output:
     while (this.vertexPrioQueue.size() > 0) {
-        QueueElem topElem = this.vertexPrioQueue.poll();
+        final QueueElem topElem = this.vertexPrioQueue.poll();
         if (topElem.getNoAssignedSplits() == 0) {


Input:
public static void alert(String[] message) {
    for (String msg : message) {
        Bukkit.broadcast(msg, "String_Node_Str");
    }
    if (Anticheat.getManager().getConfiguration().logConsole()) {
        for (String msg : message) {
            Anticheat.getManager().log(msg);
        }
    }
}

Output:
 public static void alert(String[] message) {
-    for (String msg : message) {
-        Bukkit.broadcast(msg, "String_Node_Str");
+    for (Player player : Bukkit.getOnlinePlayers()) {
+        if (player.hasPermission("String_Node_Str"))
+            ;
+        for (String msg : message) {
+            player.sendMessage(msg);
+        }
     }


Input:
public static HadoopComponent buildDistribution(String pDistribution, String pVersion) throws Exception {
    BundleContext bc = FrameworkUtil.getBundle(DistributionFactory.class).getBundleContext();
    Collection<ServiceReference<HadoopComponent>> distributions = Collections.emptyList();
    try {
        distributions = bc.getServiceReferences(HadoopComponent.class, null);
    } catch (InvalidSyntaxException e) {
        CommonExceptionHandler.process(e);
    }
    for (ServiceReference<HadoopComponent> sr : distributions) {
        HadoopComponent np = bc.getService(sr);
        String thatDistribution = np.getDistribution();
        if (Constant.DISTRIBUTION_CUSTOM.equals(thatDistribution) && thatDistribution.equals(pDistribution)) {
            return np;
        }
        if (thatDistribution != null && thatDistribution.equals(pDistribution)) {
            String thatVersion = np.getVersion();
            if (thatVersion != null && thatVersion.equals(pVersion)) {
                return np;
            }
        }
    }
    throw new Exception("String_Node_Str" + pDistribution + "String_Node_Str" + pVersion + "String_Node_Str");
}

Output:
 public static HadoopComponent buildDistribution(String pDistribution, String pVersion) throws Exception {
-    BundleContext bc = FrameworkUtil.getBundle(DistributionFactory.class).getBundleContext();
-    Collection<ServiceReference<HadoopComponent>> distributions = Collections.emptyList();
-    try {
-        distributions = bc.getServiceReferences(HadoopComponent.class, null);
-    } catch (InvalidSyntaxException e) {
-        CommonExceptionHandler.process(e);
+    final BundleContext bc = FrameworkUtil.getBundle(DistributionFactory.class).getBundleContext();
+    if (hadoopDistributions == null) {
+        synchronized (HadoopDistributionsHelper.class) {
+            if (hadoopDistributions == null) {
+                try {
+                    hadoopDistributions = bc.getServiceReferences(HadoopComponent.class, null);
+                } catch (InvalidSyntaxException e) {
+                    CommonExceptionHandler.process(e);
+                }
+            }
+        }
     }


Input:
public long getLong(Record rec) {
    try {
        CharSequence s = value.getFlyweightStr(rec);
        return s == null ? 0 : Dates.parseTime24(s);
    } catch (NumericException ignore) {
        return 0;
    }
}

Output:
         CharSequence s = value.getFlyweightStr(rec);
-        return s == null ? 0 : Dates.parseTime24(s);
+        return s == null ? Long.MIN_VALUE : Dates.parseTime24(s);
     } catch (NumericException ignore) {


Input:
private Collection<Resource> extractUnreferencedConcepts() {
    Collection<Resource> unrefConcepts = new HashSet<Resource>();
    for (Resource concept : conceptReferencingResources.keySet()) {
        if (conceptReferencingResources.get(concept).isEmpty()) {
            unrefConcepts.add(concept);
        }
    }
    return unrefConcepts;
}

Output:
 private Collection<Resource> extractUnreferencedConcepts() {
-    Collection<Resource> unrefConcepts = new HashSet<Resource>();
+    Collection<Resource> unrefConcepts = new HashSet<>();
     for (Resource concept : conceptReferencingResources.keySet()) {


Input:
private boolean isInHeaderFooter(ITextContent text, HashMap map) {
    Object generateBy = text.getGenerateBy();
    IElement parent = text.getParent();
    while (parent != null) {
        if (parent instanceof IContent) {
            IContent content = (IContent) parent;
            ReportItemDesign design = (ReportItemDesign) content.getGenerateBy();
            if (design != null && design.getQuery() != null) {
                map.put(generateBy, Boolean.FALSE);
                return false;
            }
        }
        if (parent instanceof IBandContent) {
            IBandContent bandContent = (IBandContent) parent;
            int bandType = bandContent.getBandType();
            if (bandType == IBandContent.BAND_HEADER || bandType == IBandContent.BAND_FOOTER || bandType == IBandContent.BAND_GROUP_HEADER || bandType == IBandContent.BAND_GROUP_FOOTER) {
                IElement bandParent = bandContent.getParent();
                while (bandParent instanceof IGroupContent) {
                    bandParent = bandParent.getParent();
                }
                if (bandParent instanceof ITableContent) {
                    map.put(generateBy, Boolean.TRUE);
                    return true;
                }
            }
        }
        parent = parent.getParent();
    }
    map.put(generateBy, Boolean.FALSE);
    return false;
}

Output:
             IContent content = (IContent) parent;
-            ReportItemDesign design = (ReportItemDesign) content.getGenerateBy();
-            if (design != null && design.getQuery() != null) {
+            Object parentGenerateBy = content.getGenerateBy();
+            if (parentGenerateBy instanceof ReportItemDesign) {
+                ReportItemDesign design = (ReportItemDesign) parentGenerateBy;
+                if (design.getQuery() != null) {
+                    map.put(generateBy, Boolean.FALSE);
+                    return false;
+                }
+            } else if (null != parentGenerateBy) {
                 map.put(generateBy, Boolean.FALSE);


Input:
public long lastStartedOffset() {
    if ((lastFinishedOffset + 1) > lastStartedOffset) {
        return (lastFinishedOffset + 1);
    }
    return lastStartedOffset;
}

Output:
 public long lastStartedOffset() {
-    if ((lastFinishedOffset + 1) > lastStartedOffset) {
-        return (lastFinishedOffset + 1);
+    if (lastStartedOffset == -1) {
+        return lastFinishedOffset;
     }


Input:
private void createExampleStructure() {
    try {
        File exDir = new File(baseDir, "String_Node_Str");
        exDir.mkdirs();
        System.out.println("String_Node_Str" + exDir.getAbsolutePath());
        File vdi = new File(exDir, "String_Node_Str");
        System.out.println("String_Node_Str" + vdi.getAbsolutePath() + "String_Node_Str");
        fillFile(vdi, 1024 * 1024 * 50);
        File cfg = new File(exDir, "String_Node_Str");
        System.out.println("String_Node_Str" + cfg.getAbsolutePath() + "String_Node_Str");
        BufferedWriter bw = new BufferedWriter(new FileWriter(cfg));
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.write("String_Node_Str");
        bw.close();
        File jksFile1 = new File(System.getProperty("String_Node_Str"), "String_Node_Str");
        File jksFile0 = new File(System.getProperty("String_Node_Str"), "String_Node_Str");
        if (!jksFile0.exists() || !jksFile1.exists()) {
            System.err.println("String_Node_Str");
        }
        Builder builder = KeyStore.Builder.newInstance("String_Node_Str", null, jksFile0, new KeyStore.PasswordProtection("String_Node_Str".toCharArray()));
        KeyStore keystoreTmp = builder.getKeyStore();
        X509Certificate cert = (X509Certificate) keystoreTmp.getCertificate("String_Node_Str");
        File userPemFile = new File(exDir, "String_Node_Str");
        System.out.println("String_Node_Str" + userPemFile.getAbsolutePath() + "String_Node_Str");
        PemToolkit.writePem(cert, userPemFile);
        builder = KeyStore.Builder.newInstance("String_Node_Str", null, jksFile1, new KeyStore.PasswordProtection("String_Node_Str".toCharArray()));
        keystoreTmp = builder.getKeyStore();
        cert = (X509Certificate) keystoreTmp.getCertificate("String_Node_Str");
        userPemFile = new File(exDir, "String_Node_Str");
        System.out.println("String_Node_Str" + userPemFile.getAbsolutePath() + "String_Node_Str");
        PemToolkit.writePem(cert, userPemFile);
        File ca = new File(exDir, "String_Node_Str");
        File crt = new File(exDir, "String_Node_Str");
        File key = new File(exDir, "String_Node_Str");
        System.out.println("String_Node_Str" + ca.getAbsolutePath() + "String_Node_Str");
        System.out.println("String_Node_Str" + crt.getAbsolutePath() + "String_Node_Str");
        System.out.println("String_Node_Str" + key.getAbsolutePath() + "String_Node_Str");
        fillFile(ca, 32);
        fillFile(crt, 32);
        fillFile(key, 32);
    } catch (Exception e) {
        LOG.error("String_Node_Str", e);
    }
    System.out.println("String_Node_Str");
}

Output:
         bw.close();
-        File jksFile1 = new File(System.getProperty("String_Node_Str"), "String_Node_Str");
-        File jksFile0 = new File(System.getProperty("String_Node_Str"), "String_Node_Str");
+        File jksFile1 = new File(TestPKI.getPKIDirectory(), "String_Node_Str");
+        File jksFile0 = new File(TestPKI.getPKIDirectory(), "String_Node_Str");
         if (!jksFile0.exists() || !jksFile1.exists()) {


Input:
public void castSpell(Player player) {
    PlayerInventory inventory = player.getInventory();
    if (checkInventoryRequirements(inventory)) {
        Block targetBlock = player.getTargetBlock(null, MAXDISTANCE);
        if (targetBlock.getType() != Material.AIR) {
            LivingEntity cow = player.getWorld().spawnCreature(targetBlock.getLocation(), CreatureType.COW);
            List<Entity> nearCow = cow.getNearbyEntities(10, 10, 10);
            for (int i = 0; i < nearCow.size(); i++) {
                Creature currentCreature = (Creature) nearCow.get(i);
                currentCreature.setTarget(cow);
            }
        }
    } else {
        player.sendMessage("String_Node_Str");
    }
}

Output:
             for (int i = 0; i < nearCow.size(); i++) {
-                Creature currentCreature = (Creature) nearCow.get(i);
-                currentCreature.setTarget(cow);
+                Entity currentCreature = nearCow.get(i);
+                try {
+                    if (currentCreature.getClass() != CraftPlayer.class && currentCreature.getClass() != CraftItem.class) {
+                        ((Creature) currentCreature).setTarget(cow);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
             }


Input:
public Set<QueryableEntry> getSubRecords(ComparisonType comparisonType, Comparable searchedValue) {
    MultiResultSet results = new MultiResultSet();
    indexStore.getSubRecords(results, comparisonType, convert(searchedValue));
    return results;
}

Output:
     MultiResultSet results = new MultiResultSet();
-    indexStore.getSubRecords(results, comparisonType, convert(searchedValue));
+    if (attributeType != null) {
+        indexStore.getSubRecords(results, comparisonType, convert(searchedValue));
+    }
     return results;


Input:
public PatternBuilder groupEnd(boolean optional) {
    return xpr(optional ? "String_Node_Str" : "String_Node_Str");
}

Output:
 public PatternBuilder groupEnd(boolean optional) {
-    return xpr(optional ? "String_Node_Str" : "String_Node_Str");
+    if (optional) {
+        return xpr("String_Node_Str");
+    } else {
+        return xpr("String_Node_Str");
+    }
 }


Input:
public CompilationResult compileOnMemory(Collection<CtClass> ctClassList, URL[] cp) {
    Map<String, String> toCompile = new HashMap<String, String>();
    prettyPrinter = new DefaultJavaPrettyPrinter(getEnvironment());
    try {
        for (CtClass ctClass : ctClassList) {
            this.getProcessingManager().process(ctClass);
            String[] tmp = ctClass.getQualifiedName().split("String_Node_Str");
            char[][] pack = new char[tmp.length - 1][];
            toCompile.put(ctClass.getQualifiedName(), sourceForModelledClass(ctClass));
        }
    } catch (Exception e) {
        e.printStackTrace();
        List<String> errors = new ArrayList<String>();
        errors.add(e.getMessage());
        CompilationResult rbc = new CompilationResult(null, true, errors);
        return rbc;
    }
    List<String> cps = new ArrayList<>();
    cps.add("String_Node_Str");
    String s = "String_Node_Str";
    for (URL url : cp) {
        s += ((url.getPath()) + File.pathSeparator);
    }
    cps.add(s);
    CompilationResult rbc = dcc.javaBytecodeFor(toCompile, new HashMap<String, byte[]>(), cps);
    return rbc;
}

Output:
         errors.add(e.getMessage());
-        CompilationResult rbc = new CompilationResult(null, true, errors);
+        CompilationResult rbc = new CompilationResult(null, errors);
         return rbc;


Input:
public boolean getUserHasTrust(int userId) {
    return !isTrustDisabled(userId) && mUserHasTrust.get(userId) || mUserFingerprintAuthenticated.get(userId);
}

Output:
 public boolean getUserHasTrust(int userId) {
-    return !isTrustDisabled(userId) && mUserHasTrust.get(userId) || mUserFingerprintAuthenticated.get(userId);
+    return !isTrustDisabled(userId) && mUserHasTrust.get(userId);
 }


Input:
public static RuleViolation isOutputStandard(TransactionOutput output) {
    if (MIN_ANALYSIS_NONDUST_OUTPUT.compareTo(output.getValue()) > 0)
        return RuleViolation.DUST;
    for (ScriptChunk chunk : output.getScriptPubKey().getChunks()) {
        if (chunk.isPushData() && !chunk.isShortestPossiblePushData())
            return RuleViolation.SHORTEST_POSSIBLE_PUSHDATA;
    }
    return RuleViolation.NONE;
}

Output:
 public static RuleViolation isOutputStandard(TransactionOutput output) {
-    if (MIN_ANALYSIS_NONDUST_OUTPUT.compareTo(output.getValue()) > 0)
+    if (output.getValue().compareTo(MIN_ANALYSIS_NONDUST_OUTPUT) < 0)
         return RuleViolation.DUST;


Input:
public boolean isReadOnly() {
    try {
        FileConnection c = connector();
        if (c.exists()) {
            return c.canWrite();
        } else {
            try {
                String local = this.getLocalURI();
                if (local.indexOf("String_Node_Str") == -1) {
                    return false;
                } else {
                    String parent = local.substring(0, local.lastIndexOf('/'));
                    FileConnection parentConnector = this.connector(parent, false);
                    if (parentConnector.exists() && parentConnector.isDirectory()) {
                        boolean result = parentConnector.canWrite();
                        parentConnector.close();
                        return result;
                    }
                    return false;
                }
            } catch (Exception e) {
                return false;
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
        return true;
    } catch (SecurityException se) {
        return true;
    }
}

Output:
         if (c.exists()) {
-            return c.canWrite();
+            return !c.canWrite();
         } else {


Input:
public boolean run(IRunStatus status) {
    if (null == spec.testSetup) {
        MessageUtil.abort(status, "String_Node_Str");
        return false;
    } else if (!spec.testSetup.result) {
        MessageUtil.abort(status, spec.testSetup.failureReason);
        return false;
    }
    AjcMessageHandler handler = new AjcMessageHandler(spec.getMessages());
    handler.init();
    boolean handlerResult = false;
    boolean result = false;
    boolean commandResult = false;
    ArrayList argList = new ArrayList();
    final Spec.TestSetup setupResult = spec.testSetup;
    try {
        argList.add("String_Node_Str");
        String outputDirPath = sandbox.classesDir.getAbsolutePath();
        try {
            outputDirPath = sandbox.classesDir.getCanonicalPath();
        } catch (IOException e) {
            MessageUtil.abort(status, "String_Node_Str" + sandbox.classesDir, e);
        }
        argList.add(outputDirPath);
        String path = sandbox.classpathToString(this);
        if (!LangUtil.isEmpty(path)) {
            argList.add("String_Node_Str");
            argList.add(path);
        }
        path = sandbox.getBootclasspath(this);
        if (!LangUtil.isEmpty(path)) {
            argList.add("String_Node_Str");
            argList.add(path);
        }
        path = sandbox.aspectpathToString(this);
        if (!LangUtil.isEmpty(path)) {
            argList.add("String_Node_Str");
            argList.add(path);
        }
        if (0 < injars.size()) {
            argList.add("String_Node_Str");
            argList.add(FileUtil.flatten((String[]) injars.toArray(new String[0]), null));
        }
        if (0 < inpaths.size()) {
            argList.add("String_Node_Str");
            argList.add(FileUtil.flatten((String[]) inpaths.toArray(new String[0]), null));
        }
        argList.addAll(setupResult.commandOptions);
        argList.addAll(arguments);
        if (null != setupResult.seek) {
            String slopPrefix = Spec.SEEK_MESSAGE_PREFIX + "String_Node_Str";
            PrintStream slop = MessageUtil.handlerPrintStream(status, IMessage.INFO, System.err, slopPrefix);
            List found = FileUtil.lineSeek(setupResult.seek, arguments, false, slop);
            if (!LangUtil.isEmpty(found)) {
                for (Iterator iter = found.iterator(); iter.hasNext(); ) {
                    MessageUtil.info(status, Spec.SEEK_MESSAGE_PREFIX + iter.next());
                }
            }
        }
        ICommand compiler = spec.reuseCompiler ? sandbox.getCommand(this) : ReflectionFactory.makeCommand(setupResult.compilerName, status);
        DirChanges dirChanges = null;
        if (null == compiler) {
            MessageUtil.fail(status, "String_Node_Str" + setupResult.compilerName);
            return false;
        } else {
            if (setupResult.compilerName != Spec.DEFAULT_COMPILER) {
                MessageUtil.info(status, "String_Node_Str" + setupResult.compilerName);
            }
            if (status.aborted()) {
                MessageUtil.debug(status, "String_Node_Str" + compiler);
            } else {
                if (!LangUtil.isEmpty(spec.dirChanges)) {
                    LangUtil.throwIaxIfFalse(1 == spec.dirChanges.size(), "String_Node_Str");
                    dirChanges = new DirChanges((DirChanges.Spec) spec.dirChanges.get(0));
                    if (!dirChanges.start(status, sandbox.classesDir)) {
                        return false;
                    }
                }
                MessageUtil.info(status, compiler + "String_Node_Str" + argList + "String_Node_Str");
                sandbox.setCommand(compiler, this);
                String[] args = (String[]) argList.toArray(RA_String);
                commandResult = compiler.runCommand(args, handler);
            }
        }
        handlerResult = handler.passed();
        if (!handlerResult) {
            return false;
        } else {
            result = (commandResult == handler.expectingCommandTrue());
            if (!result) {
                String m = commandResult ? "String_Node_Str" : "String_Node_Str";
                MessageUtil.fail(status, m);
            } else if (null != dirChanges) {
                result = dirChanges.end(status, sandbox.testBaseDir);
            }
        }
        return result;
    } finally {
        if (!handlerResult) {
            MessageUtil.info(handler, spec.toLongString());
            MessageUtil.info(handler, "String_Node_Str" + argList);
            if (null != setupResult) {
                MessageUtil.info(handler, "String_Node_Str" + setupResult);
            }
        }
        handler.report(status);
    }
}

Output:
     try {
-        argList.add("String_Node_Str");
-        String outputDirPath = sandbox.classesDir.getAbsolutePath();
-        try {
-            outputDirPath = sandbox.classesDir.getCanonicalPath();
-        } catch (IOException e) {
-            MessageUtil.abort(status, "String_Node_Str" + sandbox.classesDir, e);
+        if (spec.outjar == null) {
+            argList.add("String_Node_Str");
+            String outputDirPath = sandbox.classesDir.getAbsolutePath();
+            try {
+                outputDirPath = sandbox.classesDir.getCanonicalPath();
+            } catch (IOException e) {
+                MessageUtil.abort(status, "String_Node_Str" + sandbox.classesDir, e);
+            }
+            argList.add(outputDirPath);
         }


Input:
public synchronized Set<CoordinateOperation> createFromCoordinateReferenceSystemCodes(final String sourceCRS, final String targetCRS) throws FactoryException {
    ArgumentChecks.ensureNonNull("String_Node_Str", sourceCRS);
    ArgumentChecks.ensureNonNull("String_Node_Str", targetCRS);
    final String label = sourceCRS + "String_Node_Str" + targetCRS;
    final CoordinateOperationSet set = new CoordinateOperationSet(owner);
    try {
        final int[] pair = toPrimaryKeys(null, null, null, sourceCRS, targetCRS);
        boolean searchTransformations = false;
        do {
            final String key, sql;
            if (searchTransformations) {
                key = "String_Node_Str";
                sql = "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";
            } else {
                key = "String_Node_Str";
                sql = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
            }
            final Integer targetKey = searchTransformations ? null : pair[1];
            try (ResultSet result = executeQuery(key, sql, pair)) {
                while (result.next()) {
                    set.addAuthorityCode(getString(label, result, 1), targetKey);
                }
            }
        } while ((searchTransformations = !searchTransformations) == true);
        final String[] codes = set.getAuthorityCodes();
        if (codes.length > 1 && sort("String_Node_Str", codes)) {
            set.setAuthorityCodes(codes);
        }
    } catch (SQLException exception) {
        throw databaseFailure(CoordinateOperation.class, label, exception);
    }
    set.resolve(1);
    return set;
}

Output:
                 key = "String_Node_Str";
-                sql = "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";
+                sql = "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";
             } else {


Input:
String getUrlTemplate(EDatabaseVersion4Drivers version) {
    switch(version) {
        case HIVE:
            return URL_HIVE_1_STANDALONE;
        case HIVE_EMBEDDED:
            return URL_HIVE_1_EMBEDDED;
        case HIVE_2_EMBEDDED:
            return URL_HIVE_2_EMBEDDED;
        case HIVE_2_STANDALONE:
            return URL_HIVE_2_STANDALONE;
        default:
            return super.getUrlTemplate(version);
    }
}

Output:
         case HIVE_EMBEDDED:
-            return URL_HIVE_1_EMBEDDED;
+            return URL_HIVE_1_TEMPLATE;
         case HIVE_2_EMBEDDED:


Input:
private boolean deepDecrypt(final ArrayList<DownloadLink> decryptedLinks) {
    if (decryptedLinks.isEmpty())
        return false;
    final ArrayList<DownloadLink> newdecryptedLinks = new ArrayList<DownloadLink>();
    boolean hasDecryptedLinks = false;
    class DThread {
        Thread thread;
        public Thread getThread() {
            return thread;
        }
        public void setThread(Thread thread) {
            this.thread = thread;
        }
        boolean canDecrypt = false;
        public boolean couldDecrypt() {
            return canDecrypt;
        }
        public void setCouldDecrypt(boolean bool) {
            canDecrypt = bool;
        }
    }
    ArrayList<DThread> decryptThread = new ArrayList<DThread>();
    for (int b = decryptedLinks.size() - 1; b >= 0; b--) {
        final int i = b;
        final DThread dThread = new DThread();
        dThread.setThread(new Thread(new Runnable() {
            public void run() {
                DownloadLink link = decryptedLinks.get(i);
                String url = link.getDownloadURL();
                if (url != null) {
                    url = HTMLParser.getHttpLinkList(url);
                    try {
                        url = URLDecoder.decode(url, "String_Node_Str");
                    } catch (Exception e) {
                        logger.warning("String_Node_Str");
                    }
                }
                dThread.setCouldDecrypt(false);
                for (DecryptPluginWrapper pDecrypt : DecryptPluginWrapper.getDecryptWrapper()) {
                    if (pDecrypt.usePlugin() && pDecrypt.canHandle(url)) {
                        try {
                            PluginForDecrypt plg = (PluginForDecrypt) pDecrypt.getNewPluginInstance();
                            CryptedLink[] decryptableLinks = plg.getDecryptableLinks(url);
                            url = plg.cutMatches(url);
                            for (CryptedLink cLink : decryptableLinks) {
                                cLink.setDecrypterPassword(link.getDecrypterPassword());
                            }
                            ArrayList<DownloadLink> dLinks = plg.decryptLinks(decryptableLinks);
                            for (DownloadLink dLink : dLinks) {
                                dLink.addSourcePluginPasswords(link.getSourcePluginPasswords());
                            }
                            newdecryptedLinks.addAll(dLinks);
                            dThread.setCouldDecrypt(true);
                            break;
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }));
        dThread.getThread().start();
        decryptThread.add(dThread);
    }
    for (int j = decryptThread.size() - 1; j >= 0; j--) {
        DThread thread = decryptThread.get(j);
        while (thread.getThread().isAlive()) {
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if (thread.couldDecrypt()) {
            decryptedLinks.remove(j);
            hasDecryptedLinks = true;
        }
    }
    decryptedLinks.addAll(newdecryptedLinks);
    return hasDecryptedLinks;
}

Output:
         }
-    }
-    ArrayList<DThread> decryptThread = new ArrayList<DThread>();
-    for (int b = decryptedLinks.size() - 1; b >= 0; b--) {
-        final int i = b;
-        final DThread dThread = new DThread();
-        dThread.setThread(new Thread(new Runnable() {
-            public void run() {
-                DownloadLink link = decryptedLinks.get(i);
-                String url = link.getDownloadURL();
-                if (url != null) {
-                    url = HTMLParser.getHttpLinkList(url);
-                    try {
-                        url = URLDecoder.decode(url, "String_Node_Str");
-                    } catch (Exception e) {
-                        logger.warning("String_Node_Str");
-                    }
+
+        public void run() {
+            String url = link.getDownloadURL();
+            if (url != null) {
+                url = HTMLParser.getHttpLinkList(url);
+                try {
+                    url = URLDecoder.decode(url, "String_Node_Str");
+                } catch (Exception e) {
+                    logger.warning("String_Node_Str");
                 }


Input:
protected void loadConfig(URL configURL) {
    allElements.clear();
    Comparator comparator = new Comparator() {
        public int compare(Object o1, Object o2) {
            ConfigElement c1 = (ConfigElement) o1;
            ConfigElement c2 = (ConfigElement) o2;
            return c1.getDescription().compareTo(c2.getDescription());
        }
    };
    try {
        ConfigList config = ConfigList.decode(configURL.openStream());
        allElements.put(ConfigType.GENDER, Arrays.asList((ConfigElement[]) config.getGenders()));
        List<ConfigElement> headList = Arrays.asList((ConfigElement[]) config.getHeads());
        Collections.sort(headList, comparator);
        allElements.put(ConfigType.HEAD, headList);
        List<ConfigElement> hairList = Arrays.asList((ConfigElement[]) config.getHair());
        Collections.sort(hairList, comparator);
        allElements.put(ConfigType.HAIR, hairList);
        List<ConfigElement> torsoList = Arrays.asList((ConfigElement[]) config.getTorsos());
        Collections.sort(torsoList, comparator);
        allElements.put(ConfigType.TORSO, torsoList);
        List<ConfigElement> jacketList = Arrays.asList((ConfigElement[]) config.getJackets());
        Collections.sort(jacketList, comparator);
        allElements.put(ConfigType.JACKET, jacketList);
        List<ConfigElement> handsList = Arrays.asList((ConfigElement[]) config.getHands());
        Collections.sort(handsList, comparator);
        allElements.put(ConfigType.HANDS, handsList);
        List<ConfigElement> legsList = Arrays.asList((ConfigElement[]) config.getLegs());
        Collections.sort(legsList, comparator);
        allElements.put(ConfigType.LEGS, legsList);
        List<ConfigElement> feetList = Arrays.asList((ConfigElement[]) config.getFeet());
        Collections.sort(feetList, comparator);
        allElements.put(ConfigType.FEET, feetList);
        for (ConfigType type : ConfigType.values()) {
            List<ConfigElement> el = getElements(type);
            if (el.size() > 0) {
                setElement(type, 0);
            }
        }
    } catch (IOException ioe) {
        logger.log(Level.WARNING, "String_Node_Str" + configURL, ioe);
    }
}

Output:
     try {
-        ConfigList config = ConfigList.decode(configURL.openStream());
-        allElements.put(ConfigType.GENDER, Arrays.asList((ConfigElement[]) config.getGenders()));
-        List<ConfigElement> headList = Arrays.asList((ConfigElement[]) config.getHeads());
-        Collections.sort(headList, comparator);
-        allElements.put(ConfigType.HEAD, headList);
-        List<ConfigElement> hairList = Arrays.asList((ConfigElement[]) config.getHair());
-        Collections.sort(hairList, comparator);
-        allElements.put(ConfigType.HAIR, hairList);
-        List<ConfigElement> torsoList = Arrays.asList((ConfigElement[]) config.getTorsos());
-        Collections.sort(torsoList, comparator);
-        allElements.put(ConfigType.TORSO, torsoList);
-        List<ConfigElement> jacketList = Arrays.asList((ConfigElement[]) config.getJackets());
-        Collections.sort(jacketList, comparator);
-        allElements.put(ConfigType.JACKET, jacketList);
-        List<ConfigElement> handsList = Arrays.asList((ConfigElement[]) config.getHands());
-        Collections.sort(handsList, comparator);
-        allElements.put(ConfigType.HANDS, handsList);
-        List<ConfigElement> legsList = Arrays.asList((ConfigElement[]) config.getLegs());
-        Collections.sort(legsList, comparator);
-        allElements.put(ConfigType.LEGS, legsList);
-        List<ConfigElement> feetList = Arrays.asList((ConfigElement[]) config.getFeet());
-        Collections.sort(feetList, comparator);
-        allElements.put(ConfigType.FEET, feetList);
-        for (ConfigType type : ConfigType.values()) {
-            List<ConfigElement> el = getElements(type);
-            if (el.size() > 0) {
-                setElement(type, 0);
-            }
-        }
+        config = ConfigList.decode(configURL.openStream());
     } catch (IOException ioe) {


Input:
final void killServicesLocked(ProcessRecord app, boolean allowRestart) {
    if (false) {
        if (app.services.size() > 0) {
            Iterator<ServiceRecord> it = app.services.iterator();
            while (it.hasNext()) {
                ServiceRecord r = it.next();
                for (int conni = r.connections.size() - 1; conni >= 0; conni--) {
                    ArrayList<ConnectionRecord> cl = r.connections.valueAt(conni);
                    for (int i = 0; i < cl.size(); i++) {
                        ConnectionRecord c = cl.get(i);
                        if (c.binding.client != app) {
                            try {
                            } catch (Exception e) {
                                Slog.w(TAG, "String_Node_Str" + r.shortName + "String_Node_Str" + app.processName, e);
                            }
                        }
                    }
                }
            }
        }
    }
    for (int i = app.services.size() - 1; i >= 0; i--) {
        ServiceRecord sr = app.services.valueAt(i);
        synchronized (sr.stats.getBatteryStats()) {
            sr.stats.stopLaunchedLocked();
        }
        if (sr.app != null) {
            sr.app.services.remove(sr);
        }
        sr.app = null;
        sr.isolatedProc = null;
        sr.executeNesting = 0;
        sr.forceClearTracker();
        if (mDestroyingServices.remove(sr)) {
            if (DEBUG_SERVICE)
                Slog.v(TAG, "String_Node_Str" + sr);
        }
        final int numClients = sr.bindings.size();
        for (int bindingi = numClients - 1; bindingi >= 0; bindingi--) {
            IntentBindRecord b = sr.bindings.valueAt(bindingi);
            if (DEBUG_SERVICE)
                Slog.v(TAG, "String_Node_Str" + b + "String_Node_Str" + b.hasBound);
            b.binder = null;
            b.requested = b.received = b.hasBound = false;
        }
    }
    for (int i = app.connections.size() - 1; i >= 0; i--) {
        ConnectionRecord r = app.connections.valueAt(i);
        removeConnectionLocked(r, app, null);
    }
    app.connections.clear();
    ServiceMap smap = getServiceMap(app.userId);
    for (int i = app.services.size() - 1; i >= 0; i--) {
        ServiceRecord sr = app.services.valueAt(i);
        if (smap.mServicesByName.get(sr.name) != sr) {
            ServiceRecord cur = smap.mServicesByName.get(sr.name);
            Slog.wtf(TAG, "String_Node_Str" + sr + "String_Node_Str" + app + "String_Node_Str" + cur);
            app.services.removeAt(i);
            continue;
        }
        if (allowRestart && sr.crashCount >= 2 && (sr.serviceInfo.applicationInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {
            Slog.w(TAG, "String_Node_Str" + sr.crashCount + "String_Node_Str" + sr);
            EventLog.writeEvent(EventLogTags.AM_SERVICE_CRASHED_TOO_MUCH, sr.userId, sr.crashCount, sr.shortName, app.pid);
            bringDownServiceLocked(sr);
        } else if (!allowRestart) {
            bringDownServiceLocked(sr);
        } else {
            boolean canceled = scheduleServiceRestartLocked(sr, true);
            if (sr.startRequested && (sr.stopIfKilled || canceled)) {
                if (sr.pendingStarts.size() == 0) {
                    sr.startRequested = false;
                    if (sr.tracker != null) {
                        sr.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(), SystemClock.uptimeMillis());
                    }
                    if (!sr.hasAutoCreateConnections()) {
                        bringDownServiceLocked(sr);
                    }
                }
            }
        }
    }
    if (!allowRestart) {
        app.services.clear();
        for (int i = mRestartingServices.size() - 1; i >= 0; i--) {
            ServiceRecord r = mRestartingServices.get(i);
            if (r.processName.equals(app.processName) && r.serviceInfo.applicationInfo.uid == app.info.uid) {
                mRestartingServices.remove(i);
                clearRestartingIfNeededLocked(r);
            }
        }
        for (int i = mPendingServices.size() - 1; i >= 0; i--) {
            ServiceRecord r = mPendingServices.get(i);
            if (r.processName.equals(app.processName) && r.serviceInfo.applicationInfo.uid == app.info.uid) {
                mPendingServices.remove(i);
            }
        }
    }
    int i = mDestroyingServices.size();
    while (i > 0) {
        i--;
        ServiceRecord sr = mDestroyingServices.get(i);
        if (sr.app == app) {
            sr.forceClearTracker();
            mDestroyingServices.remove(i);
            if (DEBUG_SERVICE)
                Slog.v(TAG, "String_Node_Str" + sr);
        }
    }
    app.executingServices.clear();
}

Output:
         }
-        if (sr.app != null) {
+        if (sr.app != null && !sr.app.persistent) {
             sr.app.services.remove(sr);


Input:
protected boolean _clear() {
    return _queryForSave();
}

Output:
 protected boolean _clear() {
-    return _queryForSave();
+    int result = _queryForSave();
+    return (result == _SAVED || result == _DISCARDED);
 }


Input:
public void readFromNBT(NBTTagCompound nbtTagCompound) {
    super.readFromNBT(nbtTagCompound);
    managerXOffset = nbtTagCompound.getInteger("String_Node_Str");
    managerYOffset = nbtTagCompound.getInteger("String_Node_Str");
    managerZOffset = nbtTagCompound.getInteger("String_Node_Str");
    if (worldObj != null)
        manager = worldObj.getBlockTileEntity(xCoord + managerXOffset, yCoord + managerYOffset, zCoord + managerZOffset);
}

Output:
     managerZOffset = nbtTagCompound.getInteger("String_Node_Str");
-    if (worldObj != null)
+    if (worldObj != null) {
         manager = worldObj.getBlockTileEntity(xCoord + managerXOffset, yCoord + managerYOffset, zCoord + managerZOffset);


Input:
protected void handleEvents(final EPickingType ePickingType, final EPickingMode ePickingMode, final int iExternalID, final Pick pick) {
    if (remoteRenderingGLCanvas.getHierarchyLayerByGLCanvasListenerId(iUniqueId).getCapacity() > 5) {
        return;
    }
    ArrayList<Integer> iAlOldSelection;
    switch(ePickingType) {
        case POLYLINE_SELECTION:
            switch(ePickingMode) {
                case CLICKED:
                    extSelectionManager.clear();
                    iAlOldSelection = prepareSelection(horizontalSelectionManager, EViewInternalSelectionType.SELECTION);
                    horizontalSelectionManager.clearSelection(EViewInternalSelectionType.SELECTION);
                    horizontalSelectionManager.addToType(EViewInternalSelectionType.SELECTION, iExternalID);
                    if (ePolylineDataType == EInputDataType.GENE && !bAngularBrushingSelectPolyline) {
                        propagateGeneSelection(iExternalID, 2, iAlOldSelection);
                    }
                    if (bAngularBrushingSelectPolyline) {
                        bAngularBrushingSelectPolyline = false;
                        bIsAngularBrushingActive = true;
                        iSelectedLineID = iExternalID;
                        linePick = pick;
                        bIsAngularBrushingFirstTime = true;
                    }
                    bIsDisplayListDirtyLocal = true;
                    bIsDisplayListDirtyRemote = true;
                    break;
                case MOUSE_OVER:
                    extSelectionManager.clear();
                    iAlOldSelection = prepareSelection(horizontalSelectionManager, EViewInternalSelectionType.SELECTION);
                    if (ePolylineDataType == EInputDataType.GENE)
                        propagateGeneSelection(iExternalID, 1, iAlOldSelection);
                    horizontalSelectionManager.clearSelection(EViewInternalSelectionType.MOUSE_OVER);
                    horizontalSelectionManager.addToType(EViewInternalSelectionType.MOUSE_OVER, iExternalID);
                    bIsDisplayListDirtyLocal = true;
                    bIsDisplayListDirtyRemote = true;
                    break;
            }
            pickingManager.flushHits(iUniqueId, ePickingType);
            break;
        case X_AXIS_SELECTION:
            pickingManager.flushHits(iUniqueId, ePickingType);
            break;
        case Y_AXIS_SELECTION:
            switch(ePickingMode) {
                case CLICKED:
                    iAlOldSelection = prepareSelection(verticalSelectionManager, EViewInternalSelectionType.SELECTION);
                    verticalSelectionManager.clearSelection(EViewInternalSelectionType.SELECTION);
                    verticalSelectionManager.addToType(EViewInternalSelectionType.SELECTION, iExternalID);
                    if (eAxisDataType == EInputDataType.GENE) {
                        propagateGeneSelection(iExternalID, 2, iAlOldSelection);
                    }
                    rePosition(iExternalID);
                    bIsDisplayListDirtyLocal = true;
                    bIsDisplayListDirtyRemote = true;
                    break;
                case MOUSE_OVER:
                    iAlOldSelection = prepareSelection(verticalSelectionManager, EViewInternalSelectionType.MOUSE_OVER);
                    verticalSelectionManager.clearSelection(EViewInternalSelectionType.MOUSE_OVER);
                    verticalSelectionManager.addToType(EViewInternalSelectionType.MOUSE_OVER, iExternalID);
                    if (eAxisDataType == EInputDataType.GENE) {
                        propagateGeneSelection(iExternalID, 1, iAlOldSelection);
                    }
                    bIsDisplayListDirtyLocal = true;
                    bIsDisplayListDirtyRemote = true;
                    break;
            }
            pickingManager.flushHits(iUniqueId, ePickingType);
            break;
        case LOWER_GATE_TIP_SELECTION:
            switch(ePickingMode) {
                case CLICKED:
                    System.out.println("String_Node_Str");
                    break;
                case DRAGGED:
                    bIsDraggingActive = true;
                    draggedObject = EPickingType.LOWER_GATE_TIP_SELECTION;
                    iDraggedGateNumber = iExternalID;
                    break;
            }
            pickingManager.flushHits(iUniqueId, ePickingType);
            break;
        case LOWER_GATE_BOTTOM_SELECTION:
            switch(ePickingMode) {
                case CLICKED:
                    System.out.println("String_Node_Str");
                    break;
                case DRAGGED:
                    System.out.println("String_Node_Str");
                    bIsDraggingActive = true;
                    draggedObject = EPickingType.LOWER_GATE_BOTTOM_SELECTION;
                    iDraggedGateNumber = iExternalID;
                    break;
            }
            pickingManager.flushHits(iUniqueId, ePickingType);
            break;
        case PC_ICON_SELECTION:
            switch(ePickingMode) {
                case CLICKED:
                    if (iExternalID == EIconIDs.TOGGLE_RENDER_ARRAY_AS_POLYLINE.ordinal()) {
                        if (bRenderStorageHorizontally == true)
                            renderStorageAsPolyline();
                        else
                            renderStorageAsPolyline();
                    } else if (iExternalID == EIconIDs.TOGGLE_PREVENT_OCCLUSION.ordinal()) {
                        if (bPreventOcclusion == true)
                            preventOcclusion(false);
                        else
                            preventOcclusion(true);
                    } else if (iExternalID == EIconIDs.TOGGLE_RENDER_SELECTION.ordinal()) {
                        if (bRenderSelection == true)
                            renderSelection(false);
                        else
                            renderSelection(true);
                    } else if (iExternalID == EIconIDs.RESET_SELECTIONS.ordinal()) {
                        resetSelections();
                    } else if (iExternalID == EIconIDs.SAVE_SELECTIONS.ordinal()) {
                        ArrayList<Integer> iAlSelection = new ArrayList<Integer>();
                        ArrayList<Integer> iAlGroup = new ArrayList<Integer>();
                        if (bRenderSelection) {
                            Set<Integer> deselectedSet = horizontalSelectionManager.getElements(EViewInternalSelectionType.DESELECTED);
                            addSetToSelection(deselectedSet, iAlSelection, iAlGroup, -1);
                            propagateGenes(iAlSelection, iAlGroup);
                        } else {
                            Set<Integer> set = horizontalSelectionManager.getElements(EViewInternalSelectionType.NORMAL);
                            addSetToSelection(set, iAlSelection, iAlGroup, 0);
                            set = horizontalSelectionManager.getElements(EViewInternalSelectionType.MOUSE_OVER);
                            addSetToSelection(set, iAlSelection, iAlGroup, 1);
                            set = horizontalSelectionManager.getElements(EViewInternalSelectionType.SELECTION);
                            addSetToSelection(set, iAlSelection, iAlGroup, 2);
                        }
                        mergeSelection(iAlSelection, iAlGroup, null);
                        propagateGeneSet();
                        renderSelection(true);
                        extSelectionManager.clear();
                    } else if (iExternalID == EIconIDs.ANGULAR_BRUSHING.ordinal()) {
                        bAngularBrushingSelectPolyline = true;
                    }
                    bIsDisplayListDirtyLocal = true;
                    bIsDisplayListDirtyRemote = true;
                    break;
            }
            pickingManager.flushHits(iUniqueId, EPickingType.PC_ICON_SELECTION);
            break;
        case REMOVE_AXIS:
            switch(ePickingMode) {
                case CLICKED:
                    if (bRenderStorageHorizontally) {
                        alContentSelection.remove(iExternalID);
                    } else {
                        alStorageSelection.remove(iExternalID);
                    }
                    refresh();
                    break;
            }
            pickingManager.flushHits(iUniqueId, EPickingType.REMOVE_AXIS);
            break;
        case MOVE_AXIS_LEFT:
            switch(ePickingMode) {
                case CLICKED:
                    ArrayList<Integer> alSelection;
                    if (bRenderStorageHorizontally)
                        alSelection = alContentSelection;
                    else
                        alSelection = alStorageSelection;
                    if (iExternalID > 0 && iExternalID < alSelection.size()) {
                        int iTemp = alSelection.get(iExternalID - 1);
                        alSelection.set(iExternalID - 1, alSelection.get(iExternalID));
                        alSelection.set(iExternalID, iTemp);
                        refresh();
                    }
                    break;
            }
            pickingManager.flushHits(iUniqueId, EPickingType.MOVE_AXIS_LEFT);
            break;
        case MOVE_AXIS_RIGHT:
            switch(ePickingMode) {
                case CLICKED:
                    ArrayList<Integer> alSelection;
                    if (bRenderStorageHorizontally)
                        alSelection = alContentSelection;
                    else
                        alSelection = alStorageSelection;
                    if (iExternalID >= 0 && iExternalID < alSelection.size() - 1) {
                        int iTemp = alSelection.get(iExternalID + 1);
                        alSelection.set(iExternalID + 1, alSelection.get(iExternalID));
                        alSelection.set(iExternalID, iTemp);
                        refresh();
                    }
                    break;
            }
            pickingManager.flushHits(iUniqueId, EPickingType.MOVE_AXIS_RIGHT);
            break;
        case DUPLICATE_AXIS:
            switch(ePickingMode) {
                case CLICKED:
                    ArrayList<Integer> alSelection;
                    if (bRenderStorageHorizontally)
                        alSelection = alContentSelection;
                    else
                        alSelection = alStorageSelection;
                    alSelection.add(iExternalID + 1, alSelection.get(iExternalID));
                    refresh();
                    break;
            }
            pickingManager.flushHits(iUniqueId, EPickingType.DUPLICATE_AXIS);
            break;
        case ANGULAR_UPPER:
            switch(ePickingMode) {
                case DRAGGED:
                    bIsAngularDraggingActive = true;
            }
            pickingManager.flushHits(iUniqueId, EPickingType.ANGULAR_UPPER);
            break;
        case ANGULAR_LOWER:
            switch(ePickingMode) {
                case DRAGGED:
                    bIsAngularDraggingActive = true;
            }
            break;
    }
}

Output:
 protected void handleEvents(final EPickingType ePickingType, final EPickingMode ePickingMode, final int iExternalID, final Pick pick) {
-    if (remoteRenderingGLCanvas.getHierarchyLayerByGLCanvasListenerId(iUniqueId).getCapacity() > 5) {
-        return;
+    if (remoteRenderingGLCanvas != null) {
+        if (remoteRenderingGLCanvas.getHierarchyLayerByGLCanvasListenerId(iUniqueId).getCapacity() > 5) {
+            return;
+        }
     }


Input:
public void processSelection(GLAutoDrawable drawable) {
    GL2 gl = myGl;
    gl.glEnable(GL2.GL_LIGHTING);
    if (savedBlend) {
        gl.glEnable(GL.GL_BLEND);
    }
    if (savedMulti) {
        gl.glEnable(GL.GL_MULTISAMPLE);
    }
    if (!myMaxQStack.isEmpty()) {
        throw new IllegalStateException("String_Node_Str");
    }
    int w = myViewW;
    int h = myViewH;
    ByteBuffer pixels = ByteBuffer.allocate(4 * w * h);
    gl.glReadPixels(0, 0, w, h, GL2.GL_RGBA, GL2.GL_UNSIGNED_BYTE, pixels);
    HitRecord[] hits = null;
    boolean badIdWarningIssued = false;
    for (int i = 0; i < w; i++) {
        for (int j = 0; j < h; j++) {
            int r = 0xff & pixels.get();
            int g = 0xff & pixels.get();
            int b = 0xff & pixels.get();
            int a = 0xff & pixels.get();
            int colorId = r;
            colorId <<= 8;
            colorId += g;
            colorId <<= 8;
            colorId += b;
            if (colorId != 0) {
                int id = colorId - 1;
                if (id < 0 || id >= myTotalMaxQ) {
                    if (!badIdWarningIssued) {
                        System.out.printf("String_Node_Str" + "String_Node_Str", id);
                        badIdWarningIssued = true;
                    }
                } else {
                    if (hits == null) {
                        hits = new HitRecord[myTotalMaxQ];
                    }
                    HitRecord rec = hits[id];
                    if (rec == null) {
                        rec = new HitRecord(0);
                        hits[id] = rec;
                    }
                    rec.size++;
                }
            }
        }
    }
    gl.glBindFramebuffer(GL2.GL_FRAMEBUFFER, 0);
    gl.glDeleteFramebuffers(1, frameBufferId, 0);
    gl.glDeleteRenderbuffers(1, renderBufferId, 0);
    gl.glDeleteRenderbuffers(1, depthBufferId, 0);
    gl.glViewport(mySavedViewport[0], mySavedViewport[1], mySavedViewport[2], mySavedViewport[3]);
    gl.glMatrixMode(GL2.GL_PROJECTION);
    gl.glPopMatrix();
    gl.glMatrixMode(GL2.GL_MODELVIEW);
    myViewer.selectionEvent.mySelectedObjects = new LinkedList[0];
    if (hits == null) {
        myViewer.selectionEvent.mySelectedObjects = new LinkedList[0];
    } else {
        int qid = 0;
        LinkedList<HitRecord> records = new LinkedList<HitRecord>();
        int[] result = new int[1];
        Iterator<GLRenderable> it = myViewer.renderIterator();
        while (it.hasNext()) {
            GLRenderable r = it.next();
            if (r instanceof GLSelectable) {
                GLSelectable s = (GLSelectable) r;
                int numq = s.numSelectionQueriesNeeded();
                int nums = (numq >= 0 ? numq : 1);
                if (s.isSelectable()) {
                    for (int i = 0; i < nums; i++) {
                        HitRecord rec;
                        if ((rec = hits[qid + i]) != null) {
                            if (numq < 0) {
                                rec.objs.add(s);
                            } else {
                                s.getSelection(rec.objs, i);
                            }
                            if (rec.objs.size() > 0) {
                                records.add(rec);
                            }
                        }
                    }
                }
                qid += nums;
            }
        }
        Collections.sort(records);
        LinkedList<Object>[] selObjs = new LinkedList[records.size()];
        for (int i = 0; i < records.size(); i++) {
            selObjs[i] = records.get(i).objs;
        }
        myViewer.selectionEvent.mySelectedObjects = selObjs;
    }
    GLSelectionListener[] listeners = myViewer.getSelectionListeners();
    for (int i = 0; i < listeners.length; i++) {
        listeners[i].itemsSelected(myViewer.selectionEvent);
    }
    myViewer.getCanvas().repaint();
}

Output:
     int h = myViewH;
-    ByteBuffer pixels = ByteBuffer.allocate(4 * w * h);
-    gl.glReadPixels(0, 0, w, h, GL2.GL_RGBA, GL2.GL_UNSIGNED_BYTE, pixels);
+    ByteBuffer pixels = ByteBuffer.allocateDirect(4 * w * h);
+    pixels.order(ByteOrder.nativeOrder());
+    fbo.getPixelsRGBA(pixels);
+    fbo.deactivate();
+    fbo.cleanup();
+    fbo = null;
     HitRecord[] hits = null;


Input:
public boolean schemaExists() {
    Connection connection = null;
    ResultSet rset = null;
    try {
        connection = dataSource.getConnection();
        Statement stmt = connection.createStatement();
        rset = stmt.executeQuery(QUREY_SYSCHEMA_FLUME);
        if (!rset.next()) {
            LOGGER.warn("String_Node_Str");
            return false;
        }
        String flumeSchemaId = rset.getString(1);
        LOGGER.debug("String_Node_Str" + flumeSchemaId);
        connection.commit();
    } catch (SQLException ex) {
        try {
            connection.rollback();
        } catch (SQLException ex2) {
            LOGGER.error("String_Node_Str", ex2);
        }
        throw new JdbcChannelException("String_Node_Str", ex);
    } finally {
        if (rset != null) {
            try {
                rset.close();
            } catch (SQLException ex) {
                LOGGER.error("String_Node_Str", ex);
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException ex) {
                LOGGER.error("String_Node_Str", ex);
            }
        }
    }
    return true;
}

Output:
     Connection connection = null;
-    ResultSet rset = null;
+    Statement stmt = null;
     try {


Input:
public static byte[] rgb2bilevel(int[] rgb) {
    byte[] pixels = new byte[rgb.length];
    int sum = 0;
    for (int i = 0; i < rgb.length; i++) {
        pixels[i] = (byte) (((rgb[i] >> 16) & 0xff) * 0.2126 + ((rgb[i] >> 8) & 0xff) * 0.7152 + (rgb[i] & 0xff) * 0.0722);
        sum += (pixels[i] & 0xff);
    }
    int threshold = (sum / pixels.length);
    for (int l = 0; l < pixels.length; l++) {
        if ((pixels[l] & 0xff) <= threshold) {
            pixels[l] = 1;
        } else {
            pixels[l] = 0;
        }
    }
    return pixels;
}

Output:
     for (int i = 0; i < rgb.length; i++) {
-        pixels[i] = (byte) (((rgb[i] >> 16) & 0xff) * 0.2126 + ((rgb[i] >> 8) & 0xff) * 0.7152 + (rgb[i] & 0xff) * 0.0722);
+        if ((rgb[i] >>> 24) < 0x80)
+            pixels[i] = (byte) 0xff;
+        else
+            pixels[i] = (byte) (((rgb[i] >> 16) & 0xff) * 0.2126 + ((rgb[i] >> 8) & 0xff) * 0.7152 + (rgb[i] & 0xff) * 0.0722);
         sum += (pixels[i] & 0xff);


Input:
private static Conversion getConversion(Class fieldType, Field field, Annotation annotation) {
    try {
        Parsed parsed = field == null ? null : findAnnotation(field, Parsed.class);
        Class annType = annotation.annotationType();
        String nullRead = getNullReadValue(parsed);
        String nullWrite = getNullWriteValue(parsed);
        if (annType == NullString.class) {
            String[] nulls = ((NullString) annotation).nulls();
            return Conversions.toNull(nulls);
        } else if (annType == EnumOptions.class) {
            if (!fieldType.isEnum()) {
                if (field == null) {
                    throw new IllegalStateException("String_Node_Str" + EnumOptions.class.getName() + "String_Node_Str" + fieldType.getName() + "String_Node_Str");
                } else {
                    throw new IllegalStateException("String_Node_Str" + EnumOptions.class.getName() + "String_Node_Str" + field.getName() + "String_Node_Str" + field.getType().getName() + "String_Node_Str");
                }
            }
            EnumOptions enumOptions = ((EnumOptions) annotation);
            String element = enumOptions.customElement().trim();
            if (element.isEmpty()) {
                element = null;
            }
            Enum nullReadValue = nullRead == null ? null : Enum.valueOf(fieldType, nullRead);
            return new EnumConversion(fieldType, nullReadValue, nullWrite, element, enumOptions.selectors());
        } else if (annType == Trim.class) {
            int length = ((Trim) annotation).length();
            if (length == -1) {
                return Conversions.trim();
            } else {
                return Conversions.trim(length);
            }
        } else if (annType == LowerCase.class) {
            return Conversions.toLowerCase();
        } else if (annType == UpperCase.class) {
            return Conversions.toUpperCase();
        } else if (annType == Replace.class) {
            Replace replace = ((Replace) annotation);
            return Conversions.replace(replace.expression(), replace.replacement());
        } else if (annType == BooleanString.class) {
            if (fieldType != boolean.class && fieldType != Boolean.class) {
                if (field == null) {
                    throw new DataProcessingException("String_Node_Str" + BooleanString.class.getName() + "String_Node_Str" + fieldType.getName() + "String_Node_Str");
                } else {
                    throw new DataProcessingException("String_Node_Str" + field.getName() + "String_Node_Str" + fieldType.getName() + "String_Node_Str");
                }
            }
            BooleanString boolString = ((BooleanString) annotation);
            String[] falseStrings = boolString.falseStrings();
            String[] trueStrings = boolString.trueStrings();
            Boolean valueForNull = nullRead == null ? null : Boolean.valueOf(nullRead);
            if (valueForNull == null && fieldType == boolean.class) {
                valueForNull = Boolean.FALSE;
            }
            return Conversions.toBoolean(valueForNull, nullWrite, trueStrings, falseStrings);
        } else if (annType == Format.class) {
            Format format = ((Format) annotation);
            String[] formats = format.formats();
            Conversion conversion = null;
            if (fieldType == BigDecimal.class) {
                BigDecimal defaultForNull = nullRead == null ? null : new BigDecimal(nullRead);
                conversion = Conversions.formatToBigDecimal(defaultForNull, nullWrite, formats);
            } else if (Number.class.isAssignableFrom(fieldType)) {
                conversion = Conversions.formatToNumber(formats);
                ((NumericConversion) conversion).setNumberType(fieldType);
            } else {
                Date dateIfNull = null;
                if (nullRead != null) {
                    if ("String_Node_Str".equalsIgnoreCase(nullRead)) {
                        dateIfNull = new Date();
                    } else {
                        if (formats.length == 0) {
                            throw new DataProcessingException("String_Node_Str");
                        }
                        SimpleDateFormat sdf = new SimpleDateFormat(formats[0]);
                        dateIfNull = sdf.parse(nullRead);
                    }
                }
                if (Date.class == fieldType) {
                    conversion = Conversions.toDate(dateIfNull, nullWrite, formats);
                } else if (Calendar.class == fieldType) {
                    Calendar calendarIfNull = null;
                    if (dateIfNull != null) {
                        calendarIfNull = Calendar.getInstance();
                        calendarIfNull.setTime(dateIfNull);
                    }
                    conversion = Conversions.toCalendar(calendarIfNull, nullWrite, formats);
                }
            }
            if (conversion != null) {
                String[] options = format.options();
                if (options.length > 0) {
                    if (conversion instanceof FormattedConversion) {
                        Object[] formatters = ((FormattedConversion) conversion).getFormatterObjects();
                        for (Object formatter : formatters) {
                            applyFormatSettings(formatter, options);
                        }
                    } else {
                        throw new DataProcessingException("String_Node_Str" + Arrays.toString(options) + "String_Node_Str" + conversion.getClass() + "String_Node_Str" + FormattedConversion.class);
                    }
                }
                return conversion;
            }
        } else if (annType == Convert.class) {
            Convert convert = ((Convert) annotation);
            String[] args = convert.args();
            Class conversionClass = convert.conversionClass();
            if (!Conversion.class.isAssignableFrom(conversionClass)) {
                throw new DataProcessingException("String_Node_Str" + conversionClass.getSimpleName() + "String_Node_Str" + conversionClass.getName() + ')');
            }
            try {
                Constructor constructor = conversionClass.getConstructor(String[].class);
                return (Conversion) constructor.newInstance((Object) args);
            } catch (NoSuchMethodException e) {
                throw new DataProcessingException("String_Node_Str" + conversionClass.getSimpleName() + "String_Node_Str" + conversionClass.getName() + ')', e);
            } catch (Exception e) {
                throw new DataProcessingException("String_Node_Str" + conversionClass.getSimpleName() + "String_Node_Str" + conversionClass.getName() + ')', e);
            }
        }
        return null;
    } catch (DataProcessingException ex) {
        throw ex;
    } catch (Throwable ex) {
        if (field == null) {
            throw new DataProcessingException("String_Node_Str" + fieldType, ex);
        } else {
            throw new DataProcessingException("String_Node_Str" + field.getName() + "String_Node_Str" + field.getDeclaringClass().getName(), ex);
        }
    }
}

Output:
             String[] trueStrings = boolString.trueStrings();
-            Boolean valueForNull = nullRead == null ? null : Boolean.valueOf(nullRead);
+            Boolean valueForNull = nullRead == null ? null : BooleanConversion.getBoolean(nullRead, trueStrings, falseStrings);
             if (valueForNull == null && fieldType == boolean.class) {


Input:
public void log(LogRecord record) {
    if (record.getLevel().intValue() == Level.OFF.intValue() || record.getLevel().intValue() == AcsLogLevel.OFF.intValue()) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    StopWatch sw_all = null;
    if (PROFILE) {
        sw_all = new StopWatch(null);
    }
    Logger loggerWithLevel = this;
    while (loggerWithLevel != null && loggerWithLevel.getLevel() == null && loggerWithLevel.getParent() != null) {
        loggerWithLevel = loggerWithLevel.getParent();
    }
    int levelValue = -1;
    if (loggerWithLevel.getLevel() == null) {
        if (!noLevelWarningPrinted) {
            System.out.println("String_Node_Str" + getLoggerName() + "String_Node_Str");
            noLevelWarningPrinted = true;
        }
        levelValue = Level.ALL.intValue();
    } else {
        noLevelWarningPrinted = false;
        levelValue = loggerWithLevel.getLevel().intValue();
    }
    if (record.getLevel().intValue() < levelValue || levelValue == offValue) {
        return;
    }
    if (loggerName != null) {
        record.setLoggerName(loggerName);
    }
    LogParameterUtil paramUtil = new LogParameterUtil(record);
    Map<String, Object> specialProperties = paramUtil.extractSpecialPropertiesMap();
    if (specialProperties == null) {
        specialProperties = LogParameterUtil.createPropertiesMap();
        List<Object> paramList = paramUtil.getNonSpecialPropertiesMapParameters();
        paramList.add(0, specialProperties);
        record.setParameters(paramList.toArray());
        String threadName = Thread.currentThread().getName();
        specialProperties.put(LogParameterUtil.PARAM_THREAD_NAME, threadName);
        specialProperties.put(LogParameterUtil.PARAM_PROCESSNAME, this.processName);
        specialProperties.put(LogParameterUtil.PARAM_SOURCEOBJECT, this.sourceObject);
        StackTraceElement[] stack = (new Throwable()).getStackTrace();
        int ix = 0;
        boolean foundNonLogFrame = false;
        while (ix < stack.length) {
            StackTraceElement frame = stack[ix];
            String cname = frame.getClassName();
            if (!foundNonLogFrame && !loggerClassNames.contains(cname)) {
                record.setSourceClassName(cname);
                record.setSourceMethodName(frame.getMethodName());
                int lineNumber = frame.getLineNumber();
                specialProperties.put(LogParameterUtil.PARAM_LINE, Long.valueOf(lineNumber));
                foundNonLogFrame = true;
                if (this.callStacksToBeIgnored.isEmpty()) {
                    break;
                }
            }
            if (foundNonLogFrame) {
                if (callStacksToBeIgnored.contains(concatenateIgnoreLogData(cname, frame.getMethodName()))) {
                    return;
                }
            }
            ix++;
        }
    }
    StopWatch sw_afterAcsLogger = null;
    if (PROFILE) {
        sw_afterAcsLogger = sw_all.createStopWatchForSubtask("String_Node_Str");
        LogParameterUtil logParamUtil = new LogParameterUtil(record);
        logParamUtil.setStopWatch(sw_afterAcsLogger);
    }
    if (delegate != null) {
        delegate.log(record);
    } else {
        super.log(record);
    }
    if (PROFILE) {
        sw_afterAcsLogger.stop();
        sw_all.stop();
        long elapsedNanos = sw_all.getLapTimeNanos();
        if (profileSlowestCallStopWatch == null || profileSlowestCallStopWatch.getLapTimeNanos() > elapsedNanos) {
            profileSlowestCallStopWatch = sw_all;
        }
        profileLogTimeStat.addValue(elapsedNanos);
        if (profileLogTimeStat.getN() >= profileStatSize) {
            String msg = "String_Node_Str" + profileStatSize + "String_Node_Str";
            msg += "String_Node_Str" + profileLogTimeStat.getMean() * 1E-6;
            msg += "String_Node_Str" + profileLogTimeStat.getStandardDeviation() * 1E-6;
            msg += "String_Node_Str";
            System.out.println(msg);
            profileSlowestCallStopWatch.logLapTimeWithSubtaskDetails("String_Node_Str", Level.INFO);
            profileSlowestCallStopWatch = null;
            profileLogTimeStat.clear();
        }
    }
}

Output:
         long elapsedNanos = sw_all.getLapTimeNanos();
-        if (profileSlowestCallStopWatch == null || profileSlowestCallStopWatch.getLapTimeNanos() > elapsedNanos) {
+        if (profileSlowestCallStopWatch == null || profileSlowestCallStopWatch.getLapTimeNanos() < elapsedNanos) {
             profileSlowestCallStopWatch = sw_all;


Input:
public void process(Node externs, Node root) {
    (new NodeTraversal(compiler, this)).traverse(root);
}

Output:
 public void process(Node externs, Node root) {
-    (new NodeTraversal(compiler, this)).traverse(root);
+    (new NodeTraversal(compiler, this)).traverseRoots(externs, root);
 }


Input:
private static String loadRevision(DefaultHttpClient httpClient) throws IOException, ClientProtocolException {
    final String url = SERVER_ROOT + "String_Node_Str";
    HttpGet httpRequest = new HttpGet(url);
    HttpResponse response = httpClient.execute(httpRequest);
    InputStream inputStream = response.getEntity().getContent();
    return getString(inputStream);
}

Output:
     InputStream inputStream = response.getEntity().getContent();
-    return getString(inputStream);
+    return new ServerData(getString(inputStream));
 }


Input:
protected void onCreate(Bundle args) {
    super.onCreate(args);
    readArticleIdSet = new HashSet<String>();
    sharedAdapterHelper = SharedArticlesAdapterHelper.getInstance();
    if (sharedAdapterHelper.getArticleItems().size() == 0) {
        finish();
        return;
    }
    requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
    requestWindowFeature(Window.FEATURE_ACTION_BAR_OVERLAY);
    setContentView(R.layout.article_activity);
    getActionBar().setDisplayHomeAsUpEnabled(true);
    getActionBar().setHomeButtonEnabled(true);
    OnPageChangeListener onPageChangeListener = new OnPageChangeListener() {
        public void onPageSelected(int position) {
            if (position + 1 >= sharedAdapterHelper.getArticleItems().size()) {
                sharedAdapterHelper.load(ArticleActivity.this);
            }
            final JSONObject article = sharedAdapterHelper.getArticleItems().get(position);
            String articleId = article.optString("String_Node_Str");
            if (!readArticleIdSet.contains(articleId) && !article.optBoolean("String_Node_Str")) {
                readArticleIdSet.add(article.optString("String_Node_Str"));
            }
            drawerList.setItemChecked(position, true);
            drawerList.smoothScrollToPositionFromTop(position, 100);
            drawerList.invalidate();
            updateActionBar();
        }
        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
            drawerList.invalidate();
        }
        public void onPageScrollStateChanged(int state) {
        }
    };
    setTitle(getIntent().getStringExtra("String_Node_Str"));
    viewPager = (ViewPager) findViewById(R.id.viewPager);
    final ArticlesPagerAdapter adapter = new ArticlesPagerAdapter(getSupportFragmentManager());
    sharedAdapterHelper.addAdapter(adapter, articlesHelperListener);
    viewPager.setAdapter(adapter);
    int position = getIntent().getIntExtra("String_Node_Str", 0);
    UnderlinePageIndicator indicator = (UnderlinePageIndicator) findViewById(R.id.indicator);
    indicator.setViewPager(viewPager, position);
    indicator.setOnPageChangeListener(onPageChangeListener);
    drawerList = (ListView) findViewById(R.id.drawer_list);
    ArticlesAdapter listAdapter = new ArticlesAdapter(this);
    sharedAdapterHelper.addAdapter(listAdapter, null);
    AQuery aq = new AQuery(this);
    aq.id(R.id.drawer_list).adapter(listAdapter).scrolled(new AbsListView.OnScrollListener() {
        public void onScrollStateChanged(AbsListView view, int scrollState) {
        }
        public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
            if (firstVisibleItem + visibleItemCount >= totalItemCount - 2) {
                SharedArticlesAdapterHelper.getInstance().load(ArticleActivity.this);
            }
        }
    });
    drawerList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            viewPager.setCurrentItem(position);
            if (drawerLayout != null) {
                drawerLayout.closeDrawer(drawer);
            }
        }
    });
    drawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout);
    drawer = findViewById(R.id.left_drawer);
    if (drawerLayout != null) {
        drawerLayout.setDrawerShadow(R.drawable.drawer_shadow, GravityCompat.START);
        drawerLayout.setDrawerListener(new DrawerLayout.DrawerListener() {
            public void onDrawerSlide(View view, float v) {
            }
            public void onDrawerStateChanged(int i) {
            }
            public void onDrawerOpened(View view) {
                invalidateOptionsMenu();
                getActionBar().show();
            }
            public void onDrawerClosed(View view) {
                invalidateOptionsMenu();
            }
        });
    }
    viewPager.setCurrentItem(position);
    onPageChangeListener.onPageSelected(position);
}

Output:
     UnderlinePageIndicator indicator = (UnderlinePageIndicator) findViewById(R.id.indicator);
-    indicator.setViewPager(viewPager, position);
-    indicator.setOnPageChangeListener(onPageChangeListener);
+    if (indicator != null) {
+        indicator.setViewPager(viewPager, position);
+        indicator.setOnPageChangeListener(onPageChangeListener);
+    } else {
+        viewPager.setOnPageChangeListener(onPageChangeListener);
+    }
     drawerList = (ListView) findViewById(R.id.drawer_list);