Input:
public static void main(String[] args) throws IOException {
    loadProperties();
    View.setLookAndFeel();
    Configuration.loadFromFile(getConfigFile(), getReplacementsFile());
    int pos = 0;
    if (args.length > 0) {
        if (args[0].equals("String_Node_Str")) {
            Configuration.debugMode = true;
            pos++;
        }
    }
    initLogging(Configuration.debugMode);
    if (args.length < pos + 1) {
        autoCheckForUpdates();
        showModeFrame();
    } else {
        if (args[pos].equals("String_Node_Str")) {
            int port = 55555;
            for (int i = pos; i < args.length; i++) {
                if (args[i].startsWith("String_Node_Str")) {
                    try {
                        port = Integer.parseInt(args[pos].substring(2));
                    } catch (NumberFormatException nex) {
                        System.err.println("String_Node_Str");
                    }
                }
            }
            if (proxyFrame == null) {
                proxyFrame = new ProxyFrame();
            }
            proxyFrame.setPort(port);
            addTrayIcon();
            switchProxy();
        } else if (args[pos].equals("String_Node_Str")) {
            if (args.length < pos + 4) {
                badArguments();
            }
            String exportFormat = args[pos + 1];
            if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                    if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                        if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                            if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                                if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                                    if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                                        if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                                            if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                                                if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                                                    if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                                                        if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
                                                            System.err.println("String_Node_Str" + exportFormat);
                                                            badArguments();
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            File outDir = new File(args[pos + 2]);
            File inFile = new File(args[pos + 3]);
            if (!inFile.exists()) {
                System.err.println("String_Node_Str");
                badArguments();
            }
            commandLineMode = true;
            boolean exportOK;
            try {
                printHeader();
                SWF exfile = new SWF(new FileInputStream(inFile), (Boolean) Configuration.getConfig("String_Node_Str", Boolean.TRUE));
                exfile.addEventListener(new EventListener() {
                    public void handleEvent(String event, Object data) {
                        if (event.equals("String_Node_Str")) {
                            System.out.println((String) data);
                        }
                    }
                });
                if (exportFormat.equals("String_Node_Str")) {
                    System.out.println("String_Node_Str");
                    exfile.exportImages(outDir.getAbsolutePath() + File.separator + "String_Node_Str");
                    System.out.println("String_Node_Str");
                    exfile.exportShapes(outDir.getAbsolutePath() + File.separator + "String_Node_Str");
                    System.out.println("String_Node_Str");
                    exfile.exportActionScript(outDir.getAbsolutePath() + File.separator + "String_Node_Str", false, (Boolean) Configuration.getConfig("String_Node_Str", Boolean.TRUE));
                    System.out.println("String_Node_Str");
                    exfile.exportMovies(outDir.getAbsolutePath() + File.separator + "String_Node_Str");
                    System.out.println("String_Node_Str");
                    exfile.exportSounds(outDir.getAbsolutePath() + File.separator + "String_Node_Str", true, true);
                    System.out.println("String_Node_Str");
                    exfile.exportBinaryData(outDir.getAbsolutePath() + File.separator + "String_Node_Str");
                    System.out.println("String_Node_Str");
                    exfile.exportTexts(outDir.getAbsolutePath() + File.separator + "String_Node_Str", true);
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportImages(outDir.getAbsolutePath());
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportShapes(outDir.getAbsolutePath());
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str") || exportFormat.equals("String_Node_Str")) {
                    if ((pos + 5 < args.length) && (args[pos + 4].equals("String_Node_Str"))) {
                        exportOK = true;
                        for (int i = pos + 5; i < args.length; i++) {
                            exportOK = exportOK && exfile.exportAS3Class(args[i], outDir.getAbsolutePath(), exportFormat.equals("String_Node_Str"), (Boolean) Configuration.getConfig("String_Node_Str", Boolean.TRUE));
                        }
                    } else {
                        exportOK = !exfile.exportActionScript(outDir.getAbsolutePath(), exportFormat.equals("String_Node_Str"), (Boolean) Configuration.getConfig("String_Node_Str", Boolean.TRUE)).isEmpty();
                    }
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportMovies(outDir.getAbsolutePath());
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportSounds(outDir.getAbsolutePath(), true, true);
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportBinaryData(outDir.getAbsolutePath());
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportTexts(outDir.getAbsolutePath(), true);
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportTexts(outDir.getAbsolutePath(), false);
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportFla(outDir.getAbsolutePath(), inFile.getName(), applicationName, applicationVerName, version, (Boolean) Configuration.getConfig("String_Node_Str", Boolean.TRUE));
                    exportOK = true;
                } else if (exportFormat.equals("String_Node_Str")) {
                    exfile.exportXfl(outDir.getAbsolutePath(), inFile.getName(), applicationName, applicationVerName, version, (Boolean) Configuration.getConfig("String_Node_Str", Boolean.TRUE));
                    exportOK = true;
                } else {
                    exportOK = false;
                }
            } catch (Exception ex) {
                exportOK = false;
                System.err.print("String_Node_Str");
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
                System.exit(1);
            }
            if (exportOK) {
                System.out.println("String_Node_Str");
                System.exit(0);
            } else {
                System.err.println("String_Node_Str");
                System.exit(1);
            }
        } else if (args[pos].equals("String_Node_Str")) {
            if (args.length < pos + 3) {
                badArguments();
            }
            if (SWF.fws2cws(new FileInputStream(args[pos + 1]), new FileOutputStream(args[pos + 2]))) {
                System.out.println("String_Node_Str");
            } else {
                System.err.println("String_Node_Str");
            }
        } else if (args[pos].equals("String_Node_Str")) {
            if (args.length < pos + 3) {
                badArguments();
            }
            if (SWF.decompress(new FileInputStream(args[pos + 1]), new FileOutputStream(args[pos + 2]))) {
                System.out.println("String_Node_Str");
                System.exit(0);
            } else {
                System.err.println("String_Node_Str");
                System.exit(1);
            }
        } else if (args[pos].equals("String_Node_Str")) {
            if (args.length < pos + 2) {
                badArguments();
            }
            try {
                Configuration.dump_tags = true;
                SWF swf = parseSWF(args[pos + 1]);
            } catch (Exception ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
                System.exit(1);
            }
            System.exit(0);
        } else if (args[pos].equals("String_Node_Str") || args[pos].equals("String_Node_Str") || args[pos].equals("String_Node_Str")) {
            printHeader();
            printCmdLineUsage();
            System.exit(0);
        } else if (args.length == pos + 1) {
            autoCheckForUpdates();
            openFile(args[pos]);
        } else {
            badArguments();
        }
    }
}

Output:
             }
-            String exportFormat = args[pos + 1];
-            if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                    if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                        if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                            if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                                if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                                    if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                                        if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                                            if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                                                if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                                                    if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                                                        if (!exportFormat.toLowerCase().equals("String_Node_Str")) {
-                                                            System.err.println("String_Node_Str" + exportFormat);
-                                                            badArguments();
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+            String[] validExportFormats = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
+            String exportFormat = args[pos + 1].toLowerCase();
+            if (!Arrays.asList(validExportFormats).contains(exportFormat)) {
+                System.err.println("String_Node_Str" + exportFormat);
+                badArguments();
             }


Input:
public void extractData(String docName, InputOptions options, OutputStream out) throws ReportServiceException {
    IReportDocument doc = ReportEngineService.getInstance().openReportDocument(getReportDesignName(options), docName, getModuleOptions(options));
    if (doc == null) {
        throw new ReportServiceException(BirtResources.getMessage(ResourceConstants.REPORT_SERVICE_EXCEPTION_EXTRACT_DATA_NO_DOCUMENT));
    }
    Locale locale = (Locale) options.getOption(InputOptions.OPT_LOCALE);
    HttpServletRequest request = (HttpServletRequest) options.getOption(InputOptions.OPT_REQUEST);
    try {
        String extractFormat = ParameterAccessor.getExtractFormat(request);
        String extractExtension = ParameterAccessor.getExtractExtension(request);
        String resultSetName = ParameterAccessor.getResultSetName(request);
        String instanceId = ParameterAccessor.getIId(request);
        Collection columns = ParameterAccessor.getSelectedColumns(request);
        Map paramMap = ParameterAccessor.getParameterAsMap(request);
        ReportEngineService.getInstance().extractDataEx(doc, extractFormat, extractExtension, resultSetName, instanceId, columns, locale, paramMap, out);
    } catch (RemoteException e) {
        throw new ReportServiceException(e.getLocalizedMessage(), e.getCause());
    } finally {
        if (doc != null)
            doc.close();
    }
}

Output:
         String resultSetName = ParameterAccessor.getResultSetName(request);
-        String instanceId = ParameterAccessor.getIId(request);
+        String instanceId = ParameterAccessor.getInstanceId(request);
         Collection columns = ParameterAccessor.getSelectedColumns(request);


Input:
private void addItems(Context c, Collection[] mycollections, String sourceDir, String mapFile, boolean template) throws Exception {
    Map<String, String> skipItems = new HashMap<String, String>();
    System.out.println("String_Node_Str" + sourceDir);
    System.out.println("String_Node_Str" + mapFile);
    File outFile = null;
    if (!isTest) {
        if (isResume) {
            skipItems = readMapFile(mapFile);
        }
        outFile = new File(mapFile);
        mapOut = new PrintWriter(new FileWriter(outFile, isResume));
        if (mapOut == null) {
            throw new Exception("String_Node_Str" + mapFile);
        }
    }
    File d = new java.io.File(sourceDir);
    if (d == null || !d.isDirectory()) {
        throw new Exception("String_Node_Str" + sourceDir);
    }
    String[] dircontents = d.list(directoryFilter);
    Arrays.sort(dircontents);
    for (int i = 0; i < dircontents.length; i++) {
        if (skipItems.containsKey(dircontents[i])) {
            System.out.println("String_Node_Str" + dircontents[i]);
        } else {
            if (mycollections == null) {
                String path = sourceDir + File.separatorChar + dircontents[i];
                try {
                    Collection[] cols = processCollectionFile(c, path, "String_Node_Str");
                    if (cols == null) {
                        System.out.println("String_Node_Str" + dircontents[i] + "String_Node_Str");
                        continue;
                    }
                    mycollections = cols;
                } catch (IllegalArgumentException e) {
                    System.out.println(e.getMessage() + "String_Node_Str");
                    continue;
                }
            }
            addItem(c, mycollections, sourceDir, dircontents[i], mapOut, template);
            System.out.println(i + "String_Node_Str" + dircontents[i]);
            c.clearCache();
        }
    }
}

Output:
         } else {
-            if (mycollections == null) {
+            Collection[] clist;
+            if (directoryFileCollections) {
                 String path = sourceDir + File.separatorChar + dircontents[i];


Input:
public int nextInt(int lowerBound, int upperBound) {
    return RandomUtils.nextInt(lowerBound, upperBound);
}

Output:
 public int nextInt(int lowerBound, int upperBound) {
-    return RandomUtils.nextInt(lowerBound, upperBound);
+    int randomValue = RandomUtils.nextInt(0, upperBound - lowerBound);
+    return lowerBound + randomValue;
 }


Input:
protected static SGID performImport(SGID referenceID, int threadCount, List<String> inputFiles, String workerModule, boolean compressed, File outputFile, List<SGID> tagSetSGIDs, SGID adhocTagSetID, int batch_size) {
    CreateUpdateManager modelManager = SWQEFactory.getModelManager();
    Reference ref = SWQEFactory.getQueryInterface().getLatestAtomBySGID(referenceID, Reference.class);
    FeatureSet featureSet = modelManager.buildFeatureSet().setReference(ref).build();
    TagSet adHocSet;
    if (adhocTagSetID != null) {
        adHocSet = SWQEFactory.getQueryInterface().getLatestAtomBySGID(adhocTagSetID, TagSet.class);
    } else {
        adHocSet = modelManager.buildTagSet().setName("String_Node_Str" + featureSet.getSGID().getRowKey()).build();
    }
    modelManager.close();
    final FeatureImporter pmi = new FeatureImporter(threadCount);
    try {
        if (modelManager != null) {
            Iterator<String> it = inputFiles.iterator();
            ImportWorker[] workerArray = new ImportWorker[inputFiles.size()];
            int index = 0;
            while (it.hasNext()) {
                String input = (String) it.next();
                Logger.getLogger(FeatureImporter.class.getName()).info("String_Node_Str" + input);
                Class processorClass = Class.forName("String_Node_Str" + workerModule);
                workerArray[index] = (ImportWorker) processorClass.newInstance();
                workerArray[index].setWorkerName("String_Node_Str" + index);
                workerArray[index].setPmi(pmi);
                workerArray[index].setInput(input);
                workerArray[index].setFeatureSetID(featureSet.getSGID());
                workerArray[index].setAdhoctagset(adHocSet.getSGID());
                workerArray[index].setTagSetIDs(tagSetSGIDs);
                workerArray[index].setBatch_size(batch_size);
                workerArray[index].setCompressed(compressed);
                workerArray[index].setMinCoverage(0);
                workerArray[index].setMaxCoverage(0);
                workerArray[index].setMinSnpQuality(0);
                workerArray[index].setIncludeSNV(false);
                workerArray[index].setFastqConvNum(0);
                workerArray[index].setIncludeIndels(false);
                workerArray[index].setIncludeCoverage(false);
                workerArray[index].setBinSize(0);
                workerArray[index].setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                    public void uncaughtException(Thread thread, Throwable thrwbl) {
                        pmi.failedWorkers.add((ImportWorker) thread);
                    }
                });
                workerArray[index].start();
                index++;
            }
            Logger.getLogger(FeatureImporter.class.getName()).info("String_Node_Str");
            for (int i = 0; i < workerArray.length; i++) {
                workerArray[i].join();
            }
            Logger.getLogger(FeatureImporter.class.getName()).info("String_Node_Str");
        }
    } catch (Exception e) {
        Logger.getLogger(FeatureImporter.class.getName()).fatal("String_Node_Str", e);
        return null;
    }
    if (pmi.failedWorkers.size() > 0) {
        return null;
    }
    SWQEFactory.getStorage().closeStorage();
    System.out.println("String_Node_Str");
    String outputID = featureSet.getSGID().getUuid().toString();
    System.out.println(outputID);
    Map<String, String> keyValues = new HashMap<String, String>();
    keyValues.put(FEATURE_SET_ID, outputID);
    if (adhocTagSetID == null) {
        System.out.println("String_Node_Str");
        String aoutputID = adHocSet.getSGID().getUuid().toString();
        System.out.println(aoutputID);
        keyValues.put("String_Node_Str", aoutputID);
    }
    Utility.writeKeyValueFile(outputFile, keyValues);
    return featureSet.getSGID();
}

Output:
     System.out.println("String_Node_Str");
-    String outputID = featureSet.getSGID().getUuid().toString();
+    String outputID = featureSet.getSGID().getRowKey();
     System.out.println(outputID);


Input:
public AttachVolumeResponseType AttachVolume(AttachVolumeType request) throws EucalyptusCloudException {
    AttachVolumeResponseType reply = (AttachVolumeResponseType) request.getReply();
    Context ctx = Contexts.lookup();
    if (request.getDevice() == null || request.getDevice().endsWith("String_Node_Str") || request.getDevice().endsWith("String_Node_Str")) {
        throw new EucalyptusCloudException("String_Node_Str" + request.getDevice());
    }
    VmInstance vm = null;
    try {
        vm = RestrictedTypes.doPrivileged(request.getInstanceId(), VmInstance.class);
    } catch (NoSuchElementException ex) {
        LOG.debug(ex, ex);
        throw new EucalyptusCloudException("String_Node_Str" + request.getInstanceId(), ex);
    } catch (Exception ex) {
        LOG.debug(ex, ex);
        throw new EucalyptusCloudException(ex.getMessage(), ex);
    }
    Cluster cluster = null;
    try {
        cluster = Clusters.lookup(vm.lookupPartition());
    } catch (NoSuchElementException e) {
        LOG.debug(e, e);
        throw new EucalyptusCloudException("String_Node_Str" + Topology.lookup(ClusterController.class, vm.lookupPartition()));
    }
    final String deviceName = request.getDevice();
    final String volumeId = request.getVolumeId();
    try {
        vm.lookupVolumeAttachmentByDevice(deviceName);
        throw new EucalyptusCloudException("String_Node_Str" + request.getDevice());
    } catch (NoSuchElementException ex1) {
    }
    for (VmInstance iter : VmInstances.list(Predicates.not(VmState.TERMINATED))) {
        try {
            iter.lookupVolumeAttachment(volumeId);
            throw new EucalyptusCloudException("String_Node_Str" + request.getVolumeId());
        } catch (NoSuchElementException ex) {
        }
    }
    EntityWrapper<Volume> db = EntityWrapper.get(Volume.class);
    Volume volume = null;
    try {
        volume = db.getUnique(Volume.named(ctx.getUserFullName(), request.getVolumeId()));
        if (volume.getRemoteDevice() == null) {
            StorageUtil.getVolumeReply(new HashMap<String, AttachedVolume>(), Lists.newArrayList(volume));
        }
        db.commit();
    } catch (EucalyptusCloudException e) {
        LOG.debug(e, e);
        db.rollback();
        throw new EucalyptusCloudException("String_Node_Str" + request.getVolumeId());
    }
    if (!RestrictedTypes.filterPrivileged().apply(volume)) {
        throw new EucalyptusCloudException("String_Node_Str" + request.getVolumeId() + "String_Node_Str" + ctx.getUser().getName());
    }
    ServiceConfiguration sc = Partitions.lookupService(Storage.class, volume.getPartition());
    ServiceConfiguration scVm = Partitions.lookupService(Storage.class, cluster.getConfiguration().getPartition());
    if (!sc.equals(scVm)) {
        throw new EucalyptusCloudException("String_Node_Str" + request.getVolumeId());
    } else if ("String_Node_Str".equals(volume.getRemoteDevice())) {
        throw new EucalyptusCloudException("String_Node_Str" + request.getVolumeId());
    }
    AttachStorageVolumeResponseType scAttachResponse;
    try {
        scAttachResponse = ServiceDispatcher.lookup(sc).send(new AttachStorageVolumeType(cluster.getNode(vm.getServiceTag()).getIqn(), volume.getDisplayName()));
    } catch (Exception e) {
        LOG.debug(e, e);
        throw new EucalyptusCloudException(e.getMessage());
    }
    request.setRemoteDevice(scAttachResponse.getRemoteDeviceString());
    AttachedVolume attachVol = new AttachedVolume(volume.getDisplayName(), vm.getInstanceId(), request.getDevice(), request.getRemoteDevice());
    volume.setState(State.BUSY);
    attachVol.setStatus("String_Node_Str");
    vm.addVolumeAttachment(attachVol);
    AsyncRequests.newRequest(new VolumeAttachCallback(request, attachVol)).dispatch(cluster.getConfiguration());
    EventRecord.here(VolumeManager.class, EventClass.VOLUME, EventType.VOLUME_ATTACH).withDetails(volume.getOwner().toString(), volume.getDisplayName(), "String_Node_Str", vm.getInstanceId()).withDetails("String_Node_Str", vm.lookupPartition().toString()).info();
    reply.setAttachedVolume(attachVol);
    return reply;
}

Output:
     try {
-        cluster = Clusters.lookup(vm.lookupPartition());
+        ServiceConfiguration ccConfig = Topology.lookup(ClusterController.class, vm.lookupPartition());
+        cluster = Clusters.lookup(ccConfig);
     } catch (NoSuchElementException e) {


Input:
private void addIfValidCoordinate(final int x, final int y, List<Point> tileCoords) {
    if ((x >= 0 && x < mapData.getWidth() && y >= 0 && y < mapData.getHeight())) {
        tileCoords.add(new Point(x, y));
    }
}

Output:
 private void addIfValidCoordinate(final int x, final int y, List<Point> tileCoords) {
-    if ((x >= 0 && x < mapData.getWidth() && y >= 0 && y < mapData.getHeight())) {
-        tileCoords.add(new Point(x, y));
+    TileData tile = mapData.getTile(x, y);
+    if (tile != null) {
+        tileCoords.add(tile.getLocation());
     }


Input:
public void setFoldRotation(float rotation) {
    foldRotation = rotation;
    topPart.applyFoldRotation(rotation);
    bottomPart.applyFoldRotation(rotation);
    setInTransformation(rotation != 0f);
    if (isAutoScaleEnabled) {
        scaleFactor = 1f;
        if (width > 0) {
            double sin = Math.abs(Math.sin(Math.toRadians(rotation)));
            float dw = (float) (height * sin) * CAMERA_DISTANCE_MAGIC_FACTOR;
            scaleFactor = width / (width + dw);
        }
        setScale(scale);
    }
}

Output:
     setInTransformation(rotation != 0f);
-    if (isAutoScaleEnabled) {
-        scaleFactor = 1f;
-        if (width > 0) {
-            double sin = Math.abs(Math.sin(Math.toRadians(rotation)));
-            float dw = (float) (height * sin) * CAMERA_DISTANCE_MAGIC_FACTOR;
-            scaleFactor = width / (width + dw);
-        }
+    scaleFactor = 1f;
+    if (isAutoScaleEnabled && width > 0) {
+        double sin = Math.abs(Math.sin(Math.toRadians(rotation)));
+        float dw = (float) (height * sin) * CAMERA_DISTANCE_MAGIC_FACTOR;
+        scaleFactor = width / (width + dw);
         setScale(scale);


Input:
public Client getClient() {
    return this.client;
}

Output:
 public Client getClient() {
-    return this.client;
+    return client;
 }


Input:
private Object instantiatePojoWithoutConstructors(Class<?> pojoClass, Map<Class<?>, Integer> pojos, Type... genericTypeArgs) throws InstantiationException, IllegalAccessException, InvocationTargetException, ClassNotFoundException {
    Object retValue = null;
    final Map<String, Type> typeArgsMap = new HashMap<String, Type>();
    Type[] genericTypeArgsExtra = fillTypeArgMap(typeArgsMap, pojoClass, genericTypeArgs);
    Method[] declaredMethods = pojoClass.getDeclaredMethods();
    strategy.sort(declaredMethods);
    Object[] parameterValues = null;
    Object[] noParams = new Object[] {};
    for (Method candidateConstructor : declaredMethods) {
        if (!Modifier.isStatic(candidateConstructor.getModifiers()) || !candidateConstructor.getReturnType().equals(pojoClass) || retValue != null) {
            continue;
        }
        parameterValues = new Object[candidateConstructor.getParameterTypes().length];
        Class<?>[] parameterTypes = candidateConstructor.getParameterTypes();
        if (parameterTypes.length == 0) {
            parameterValues = noParams;
        } else {
            Annotation[][] parameterAnnotations = candidateConstructor.getParameterAnnotations();
            int idx = 0;
            for (Class<?> parameterType : parameterTypes) {
                List<Annotation> annotations = Arrays.asList(parameterAnnotations[idx]);
                Type genericType = candidateConstructor.getGenericParameterTypes()[idx];
                parameterValues[idx] = manufactureParameterValue(parameterType, genericType, annotations, typeArgsMap, genericTypeArgsExtra, pojos, genericTypeArgs);
                idx++;
            }
        }
        try {
            retValue = candidateConstructor.invoke(pojoClass, parameterValues);
            LOG.debug("String_Node_Str" + candidateConstructor);
        } catch (Exception t) {
            LOG.debug("String_Node_Str" + candidateConstructor + "String_Node_Str", t);
        }
    }
    if (retValue == null) {
        retValue = externalFactory.manufacturePojo(pojoClass, genericTypeArgs);
    }
    if (retValue == null) {
        LOG.warn("String_Node_Str" + "String_Node_Str", pojoClass);
    }
    return retValue;
}

Output:
                 Type genericType = candidateConstructor.getGenericParameterTypes()[idx];
-                parameterValues[idx] = manufactureParameterValue(parameterType, genericType, annotations, typeArgsMap, genericTypeArgsExtra, pojos, genericTypeArgs);
+                parameterValues[idx] = manufactureParameterValue(parameterType, genericType, annotations, typeArgsMap, pojos, genericTypeArgsExtra == null ? NO_TYPES : genericTypeArgsExtra);
                 idx++;


Input:
public void stop() {
    stop = true;
    synchronized (monitor) {
        try {
            monitor.wait();
        } catch (final InterruptedException e) {
        }
    }
}

Output:
         try {
-            monitor.wait();
+            while (synchronizer != null) {
+                monitor.wait();
+            }
         } catch (final InterruptedException e) {


Input:
public void addPersistenceNew(ClassDetails classDetails) {
    CodeVisitor cv_new = cv.visitMethod(ACC_PUBLIC, "String_Node_Str", "String_Node_Str" + PERSISTENCE_OBJECT_SIGNATURE + "String_Node_Str", null, null);
    cv_new.visitTypeInsn(NEW, classDetails.getClassName());
    cv_new.visitInsn(DUP);
    cv_new.visitVarInsn(ALOAD, 1);
    cv_new.visitMethodInsn(INVOKESPECIAL, classDetails.getClassName(), "String_Node_Str", "String_Node_Str" + PERSISTENCE_OBJECT_SIGNATURE + "String_Node_Str");
    cv_new.visitInsn(ARETURN);
    cv_new.visitMaxs(0, 0);
    CodeVisitor cv_constructor = cv.visitMethod(ACC_PUBLIC, "String_Node_Str", "String_Node_Str" + PERSISTENCE_OBJECT_SIGNATURE + "String_Node_Str", null, null);
    cv_constructor.visitVarInsn(ALOAD, 0);
    if (classDetails.getSuperClassDetails() == null) {
        cv_constructor.visitMethodInsn(INVOKESPECIAL, classDetails.getSuperClassName(), "String_Node_Str", "String_Node_Str");
    } else {
        cv_constructor.visitVarInsn(ALOAD, 1);
        cv_constructor.visitMethodInsn(INVOKESPECIAL, classDetails.getSuperClassName(), "String_Node_Str", "String_Node_Str" + PERSISTENCE_OBJECT_SIGNATURE + "String_Node_Str");
    }
    cv_constructor.visitInsn(RETURN);
    cv_constructor.visitMaxs(0, 0);
}

Output:
     cv_new.visitInsn(DUP);
-    cv_new.visitVarInsn(ALOAD, 1);
-    cv_new.visitMethodInsn(INVOKESPECIAL, classDetails.getClassName(), "String_Node_Str", "String_Node_Str" + PERSISTENCE_OBJECT_SIGNATURE + "String_Node_Str");
+    if (!classDetails.canWeaveConstructorOptimization()) {
+        cv_new.visitMethodInsn(INVOKESPECIAL, classDetails.getClassName(), "String_Node_Str", "String_Node_Str");
+        cv_new.visitInsn(ARETURN);
+        cv_new.visitMaxs(0, 0);
+        return;
+    } else {
+        cv_new.visitVarInsn(ALOAD, 1);
+        cv_new.visitMethodInsn(INVOKESPECIAL, classDetails.getClassName(), "String_Node_Str", "String_Node_Str" + PERSISTENCE_OBJECT_SIGNATURE + "String_Node_Str");
+    }
     cv_new.visitInsn(ARETURN);


Input:
public void testAcceptedUsage() throws IOException {
    ExtendedRecord record = ExtendedRecordCustomBuilder.create().name("String_Node_Str").id(TEST_RECORD_ID).build();
    enqueueResponse(AGALLISUS_LEPTUROIDES_RESPONSE);
    TaxonRecord taxonRecord = new TaxonRecord();
    TaxonomyInterpreter.taxonomyInterpreter(taxonRecord, WS_PROPERTIES_PATH).apply(record);
    Assert.assertEquals(1118030, taxonRecord.getUsage().getKey().intValue());
    Assert.assertEquals(1118026, taxonRecord.getAcceptedUsage().getKey().intValue());
    Assert.assertEquals("String_Node_Str", taxonRecord.getUsage().getName());
    Assert.assertEquals("String_Node_Str", taxonRecord.getAcceptedUsage().getName());
}

Output:
     TaxonRecord taxonRecord = new TaxonRecord();
-    TaxonomyInterpreter.taxonomyInterpreter(taxonRecord, WS_PROPERTIES_PATH).apply(record);
+    Interpretation<ExtendedRecord> interpretation = TaxonomyInterpreter.taxonomyInterpreter(taxonRecord, WS_PROPERTIES_PATH).apply(record);
+    Assert.assertNotNull(interpretation);
     Assert.assertEquals(1118030, taxonRecord.getUsage().getKey().intValue());


Input:
protected void throwExceptionIfNull(Object o) {
    if (o == null) {
        throw new NullPointerException("String_Node_Str");
    }
}

Output:
     if (o == null) {
-        throw new NullPointerException("String_Node_Str");
+        throw new NullPointerException(message);
     }


Input:
public void initData() {
    super.initData();
    initHierarchy();
    calculateTextures();
    initPosCursorLevel1();
    if (bSkipLevel2 == false) {
        initPosCursorLevel2();
    }
    glHeatMapView.setSet(set);
    glHeatMapView.setContentVAType(EVAType.CONTENT_EMBEDDED_HM);
    glHeatMapView.initData();
    glGeneDendrogramView.setSet(set);
    glGeneDendrogramView.setContentVAType(EVAType.CONTENT);
    glGeneDendrogramView.initData();
    glExperimentDendrogramView.setSet(set);
    glExperimentDendrogramView.setContentVAType(EVAType.STORAGE);
    glExperimentDendrogramView.initData();
    if (bSkipLevel2 == false)
        bRedrawTextures = true;
}

Output:
     glExperimentDendrogramView.setSet(set);
-    glExperimentDendrogramView.setContentVAType(EVAType.STORAGE);
+    glExperimentDendrogramView.setContentVAType(EVAType.CONTENT);
     glExperimentDendrogramView.initData();


Input:
public SetReference<PrivateNetworkIndex, VmInstance> allocateNetworkIndex() throws TransactionException {
    EntityTransaction db = Entities.get(ExtantNetwork.class);
    SetReference<PrivateNetworkIndex, VmInstance> ref = null;
    try {
        ExtantNetwork exNet = Entities.merge(this);
        PrivateNetworkIndex netIdx = null;
        for (Long i : Numbers.shuffled(NetworkGroups.networkIndexInterval())) {
            try {
                Entities.uniqueResult(PrivateNetworkIndex.create(this, i));
                continue;
            } catch (Exception ex) {
                try {
                    netIdx = PrivateNetworkIndex.create(exNet, i);
                    netIdx = Entities.persist(netIdx);
                    exNet.getIndexes().add(netIdx);
                    exNet = Entities.merge(exNet);
                    break;
                } catch (Exception ex1) {
                    continue;
                }
            }
        }
        if (netIdx != null) {
            try {
                ref = netIdx.allocate();
                Entities.merge(this);
                db.commit();
                return ref;
            } catch (Exception ex1) {
                db.rollback();
                throw new TransactionExecutionException("String_Node_Str" + this.displayName);
            }
        } else {
            throw new TransactionExecutionException("String_Node_Str" + this.displayName);
        }
    } catch (TransactionException ex) {
        throw ex;
    } catch (Exception ex) {
        throw new TransactionExecutionException("String_Node_Str" + this.displayName, ex);
    }
}

Output:
 public SetReference<PrivateNetworkIndex, VmInstance> allocateNetworkIndex() throws TransactionException {
-    EntityTransaction db = Entities.get(ExtantNetwork.class);
-    SetReference<PrivateNetworkIndex, VmInstance> ref = null;
-    try {
-        ExtantNetwork exNet = Entities.merge(this);
-        PrivateNetworkIndex netIdx = null;
-        for (Long i : Numbers.shuffled(NetworkGroups.networkIndexInterval())) {
-            try {
-                Entities.uniqueResult(PrivateNetworkIndex.create(this, i));
-                continue;
-            } catch (Exception ex) {
+    if (!NetworkGroups.networkingConfiguration().hasNetworking()) {
+        return PrivateNetworkIndex.bogus().allocate();
+    } else if (!Entities.isPersistent(this)) {
+        throw new TransientEntityException(this.toString());
+    } else {
+        EntityTransaction db = Entities.get(ExtantNetwork.class);
+        SetReference<PrivateNetworkIndex, VmInstance> ref = null;
+        try {
+            PrivateNetworkIndex netIdx = null;
+            for (Long i : Numbers.shuffled(NetworkGroups.networkIndexInterval())) {
                 try {


Input:
public void onPageStarted(WebView view, String url, Bitmap favicon) {
    super.onPageStarted(view, url, favicon);
    final AppCompatActivity activity = mActivity;
    if (activity != null) {
        activity.setTitle(url);
    }
}

Output:
     super.onPageStarted(view, url, favicon);
-    final AppCompatActivity activity = mActivity;
-    if (activity != null) {
-        activity.setTitle(url);
+    if (mUrl != null && url != null) {
+        final AppCompatActivity activity = mActivity;
+        if (activity != null) {
+            activity.setTitle(url);
+        }
     }


Input:
private void disconnectService() {
    unbindService(servConnection);
    connectedToService = false;
}

Output:
 private void disconnectService() {
-    unbindService(servConnection);
+    if (servConnection != null) {
+        unbindService(servConnection);
+    }
     connectedToService = false;


Input:
public Connection openConnection() throws SQLException, ClassNotFoundException {
    if (checkConnection()) {
        return this.connection;
    }
    if (!this.plugin.getDataFolder().exists()) {
        this.plugin.getDataFolder().mkdirs();
    }
    final File file = new File(this.plugin.getDataFolder(), this.dbLocation);
    if (!(file.exists())) {
        try {
            file.createNewFile();
        } catch (final IOException e) {
            this.plugin.getLogger().log(Level.SEVERE, "String_Node_Str");
        }
    }
    Class.forName("String_Node_Str");
    this.connection = DriverManager.getConnection("String_Node_Str" + this.plugin.getDataFolder().toPath().toString() + "String_Node_Str" + this.dbLocation);
    return this.connection;
}

Output:
     }
-    final File file = new File(this.plugin.getDataFolder(), this.dbLocation);
+    final File file = new File(this.dbLocation);
     if (!(file.exists())) {


Input:
public void setAccountid(boolean accountid) {
    this.accountid = accountid ? 'T' : 'F';
}

Output:
 public void setAccountid(boolean accountid) {
-    this.accountid = accountid ? 'T' : 'F';
+    this.accountid = getBooleanAsCharacter(accountid);
 }


Input:
protected static double chiSquared(int[][] contingencyTable, Object[] categoryA, Object[] categoryB) {
    double testStatistic = 0.0;
    int numSamples = 0;
    for (int i = 0; i < contingencyTable.length; i++) for (int j = 0; j < contingencyTable[i].length; j++) numSamples += contingencyTable[i][j];
    for (int r = 0; r < categoryA.length; r++) for (int c = 0; c < categoryB.length; c++) {
        double eij = cellExpectation(contingencyTable, r, c, numSamples);
        if (eij == 0.0)
            continue;
        testStatistic += Math.pow(contingencyTable[r][c] - eij, 2.0) / eij;
    }
    return testStatistic;
}

Output:
     int numSamples = 0;
-    for (int i = 0; i < contingencyTable.length; i++) for (int j = 0; j < contingencyTable[i].length; j++) numSamples += contingencyTable[i][j];
+    for (int[] aContingencyTable : contingencyTable) for (int anAContingencyTable : aContingencyTable) numSamples += anAContingencyTable;
     for (int r = 0; r < categoryA.length; r++) for (int c = 0; c < categoryB.length; c++) {


Input:
private Map<Label, Map<Label, Integer>> getChooseCounts(DepTreebank treebank) {
    Map<Label, Map<Label, Integer>> chooseCounts = new HashMap<Label, Map<Label, Integer>>();
    for (DepTree tree : treebank) {
        for (DepTreeNode parentNode : tree) {
            Label parent = parentNode.getLabel();
            for (DepTreeNode childNode : parentNode.getChildren()) {
                Label child = childNode.getLabel();
                Utilities.increment(chooseCounts, parent, child, 1);
            }
        }
    }
    return chooseCounts;
}

Output:
             Label parent = parentNode.getLabel();
-            for (DepTreeNode childNode : parentNode.getChildren()) {
-                Label child = childNode.getLabel();
-                Utilities.increment(chooseCounts, parent, child, 1);
+            for (String lr : DmvModelFactory.leftRight) {
+                List<DepTreeNode> sideChildren = parentNode.getChildrenToSide(lr);
+                Pair<Label, String> pair = new Pair<Label, String>(parent, lr);
+                for (DepTreeNode childNode : sideChildren) {
+                    Label child = childNode.getLabel();
+                    Utilities.increment(chooseCounts, pair, child, 1);
+                }
             }


Input:
public void getOptions() {
    autoSelect = options.autoSelect.isSelected();
    if (fullColour != options.fullColour.isSelected()) {
        formatChange = true;
        forceNonincremental = true;
    }
    fullColour = options.fullColour.isSelected();
    if (!fullColour) {
        int newLowColourLevel = (options.veryLowColour.isSelected() ? 0 : options.lowColour.isSelected() ? 1 : 2);
        if (newLowColourLevel != lowColourLevel) {
            lowColourLevel = newLowColourLevel;
            formatChange = true;
            forceNonincremental = true;
        }
    }
    int newEncoding = (options.zrle.isSelected() ? Encodings.encodingZRLE : options.hextile.isSelected() ? Encodings.encodingHextile : options.tight.isSelected() ? Encodings.encodingTight : Encodings.encodingRaw);
    if (newEncoding != currentEncoding) {
        currentEncoding = newEncoding;
        encodingChange = true;
    }
    viewer.customCompressLevel.setParam(options.customCompressLevel.isSelected());
    if (cp.customCompressLevel != viewer.customCompressLevel.getValue()) {
        cp.customCompressLevel = viewer.customCompressLevel.getValue();
        encodingChange = true;
    }
    if (Integer.parseInt(options.compressLevel.getSelectedItem().toString()) >= 0 && Integer.parseInt(options.compressLevel.getSelectedItem().toString()) <= 9) {
        viewer.compressLevel.setParam(options.compressLevel.getSelectedItem().toString());
    } else {
        viewer.compressLevel.setParam(viewer.compressLevel.getDefaultStr());
    }
    if (cp.compressLevel != viewer.compressLevel.getValue()) {
        cp.compressLevel = viewer.compressLevel.getValue();
        encodingChange = true;
    }
    viewer.noJpeg.setParam(!options.noJpeg.isSelected());
    if (cp.noJpeg != viewer.noJpeg.getValue()) {
        cp.noJpeg = viewer.noJpeg.getValue();
        encodingChange = true;
    }
    viewer.qualityLevel.setParam(options.qualityLevel.getSelectedItem().toString());
    if (cp.qualityLevel != viewer.qualityLevel.getValue()) {
        cp.qualityLevel = viewer.qualityLevel.getValue();
        encodingChange = true;
    }
    viewer.sendLocalUsername.setParam(options.sendLocalUsername.isSelected());
    viewer.viewOnly.setParam(options.viewOnly.isSelected());
    viewer.acceptClipboard.setParam(options.acceptClipboard.isSelected());
    viewer.sendClipboard.setParam(options.sendClipboard.isSelected());
    viewer.acceptBell.setParam(options.acceptBell.isSelected());
    String scaleString = options.scalingFactor.getSelectedItem().toString();
    String oldScaleFactor = viewer.scalingFactor.getValue();
    if (scaleString.equalsIgnoreCase("String_Node_Str")) {
        if (!oldScaleFactor.equals(scaleString)) {
            viewer.scalingFactor.setParam("String_Node_Str");
            if (desktop != null && !(options.fullScreen.isSelected() && fullScreen))
                reconfigureViewport();
        }
    } else if (scaleString.equalsIgnoreCase("String_Node_Str")) {
        if (!oldScaleFactor.equalsIgnoreCase("String_Node_Str")) {
            viewer.scalingFactor.setParam("String_Node_Str");
            if (desktop != null && !(options.fullScreen.isSelected() && fullScreen))
                reconfigureViewport();
        }
    } else {
        scaleString = scaleString.substring(0, scaleString.length() - 1);
        if (!oldScaleFactor.equals(scaleString)) {
            viewer.scalingFactor.setParam(scaleString);
            if ((desktop != null) && (!oldScaleFactor.equalsIgnoreCase("String_Node_Str") || !oldScaleFactor.equalsIgnoreCase("String_Node_Str"))) {
                if (!(options.fullScreen.isSelected() && fullScreen))
                    reconfigureViewport();
            }
        }
    }
    clipboardDialog.setSendingEnabled(viewer.sendClipboard.getValue());
    viewer.menuKey.setParam(MenuKey.getMenuKeySymbols()[options.menuKey.getSelectedIndex()].name);
    F8Menu.f8.setText("String_Node_Str" + KeyEvent.getKeyText(MenuKey.getMenuKeyCode()));
    setShared(options.shared.isSelected());
    viewer.useLocalCursor.setParam(options.useLocalCursor.isSelected());
    if (cp.supportsLocalCursor != viewer.useLocalCursor.getValue()) {
        cp.supportsLocalCursor = viewer.useLocalCursor.getValue();
        encodingChange = true;
        if (desktop != null)
            desktop.resetLocalCursor();
    }
    checkEncodings();
    if (state() != RFBSTATE_NORMAL) {
        if (options.encNone.isSelected()) {
            if (options.secNone.isSelected())
                Security.EnableSecType(Security.secTypeNone);
            if (options.secVnc.isSelected())
                Security.EnableSecType(Security.secTypeVncAuth);
            if (options.secPlain.isSelected())
                Security.EnableSecType(Security.secTypePlain);
            if (options.secIdent.isSelected())
                Security.EnableSecType(Security.secTypeIdent);
        } else {
            Security.DisableSecType(Security.secTypeNone);
            Security.DisableSecType(Security.secTypeVncAuth);
            Security.DisableSecType(Security.secTypePlain);
            Security.DisableSecType(Security.secTypeIdent);
        }
        if (options.encTLS.isSelected()) {
            if (options.secNone.isSelected())
                Security.EnableSecType(Security.secTypeTLSNone);
            if (options.secVnc.isSelected())
                Security.EnableSecType(Security.secTypeTLSVnc);
            if (options.secPlain.isSelected())
                Security.EnableSecType(Security.secTypeTLSPlain);
            if (options.secIdent.isSelected())
                Security.EnableSecType(Security.secTypeTLSIdent);
        } else {
            Security.DisableSecType(Security.secTypeTLSNone);
            Security.DisableSecType(Security.secTypeTLSVnc);
            Security.DisableSecType(Security.secTypeTLSPlain);
            Security.DisableSecType(Security.secTypeTLSIdent);
        }
        if (options.encX509.isSelected()) {
            if (options.secNone.isSelected())
                Security.EnableSecType(Security.secTypeX509None);
            if (options.secVnc.isSelected())
                Security.EnableSecType(Security.secTypeX509Vnc);
            if (options.secPlain.isSelected())
                Security.EnableSecType(Security.secTypeX509Plain);
            if (options.secIdent.isSelected())
                Security.EnableSecType(Security.secTypeX509Ident);
        } else {
            Security.DisableSecType(Security.secTypeX509None);
            Security.DisableSecType(Security.secTypeX509Vnc);
            Security.DisableSecType(Security.secTypeX509Plain);
            Security.DisableSecType(Security.secTypeX509Ident);
        }
        if (options.secNone.isSelected()) {
            if (options.encNone.isSelected())
                Security.EnableSecType(Security.secTypeNone);
            if (options.encTLS.isSelected())
                Security.EnableSecType(Security.secTypeTLSNone);
            if (options.encX509.isSelected())
                Security.EnableSecType(Security.secTypeX509None);
        } else {
            Security.DisableSecType(Security.secTypeNone);
            Security.DisableSecType(Security.secTypeTLSNone);
            Security.DisableSecType(Security.secTypeX509None);
        }
        if (options.secVnc.isSelected()) {
            if (options.encNone.isSelected())
                Security.EnableSecType(Security.secTypeVncAuth);
            if (options.encTLS.isSelected())
                Security.EnableSecType(Security.secTypeTLSVnc);
            if (options.encX509.isSelected())
                Security.EnableSecType(Security.secTypeX509Vnc);
        } else {
            Security.DisableSecType(Security.secTypeVncAuth);
            Security.DisableSecType(Security.secTypeTLSVnc);
            Security.DisableSecType(Security.secTypeX509Vnc);
        }
        if (options.secPlain.isSelected()) {
            if (options.encNone.isSelected())
                Security.EnableSecType(Security.secTypePlain);
            if (options.encTLS.isSelected())
                Security.EnableSecType(Security.secTypeTLSPlain);
            if (options.encX509.isSelected())
                Security.EnableSecType(Security.secTypeX509Plain);
        } else {
            Security.DisableSecType(Security.secTypePlain);
            Security.DisableSecType(Security.secTypeTLSPlain);
            Security.DisableSecType(Security.secTypeX509Plain);
        }
        if (options.secIdent.isSelected()) {
            if (options.encNone.isSelected())
                Security.EnableSecType(Security.secTypeIdent);
            if (options.encTLS.isSelected())
                Security.EnableSecType(Security.secTypeTLSIdent);
            if (options.encX509.isSelected())
                Security.EnableSecType(Security.secTypeX509Ident);
        } else {
            Security.DisableSecType(Security.secTypeIdent);
            Security.DisableSecType(Security.secTypeTLSIdent);
            Security.DisableSecType(Security.secTypeX509Ident);
        }
    }
    if (options.fullScreen.isSelected() ^ fullScreen)
        toggleFullScreen();
}

Output:
     if (scaleString.equalsIgnoreCase("String_Node_Str")) {
-        if (!oldScaleFactor.equals(scaleString)) {
-            viewer.scalingFactor.setParam("String_Node_Str");
-            if (desktop != null && !(options.fullScreen.isSelected() && fullScreen))
-                reconfigureViewport();
-        }
+        scaleString = new String("String_Node_Str");
     } else if (scaleString.equalsIgnoreCase("String_Node_Str")) {


Input:
public static void setStepToScale(AutoScale sc, Object oStep, Integer oStepNumber, RunTimeContext rtc) throws ChartException {
    if (oStep != null) {
        sc.oStep = oStep;
        sc.bStepFixed = true;
        if (((Double) sc.oStep).doubleValue() <= 0) {
            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { oStep }, Messages.getResourceBundle(rtc.getULocale()));
        }
    }
    if (oStepNumber != null) {
        sc.oStepNumber = oStepNumber;
        sc.bStepFixed = true;
        if (sc.oStepNumber.intValue() < 1) {
            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { oStepNumber }, Messages.getResourceBundle(rtc.getULocale()));
        }
    }
}

Output:
     if (oStep != null) {
-        sc.oStep = oStep;
+        sc.setStep(oStep);
         sc.bStepFixed = true;


Input:
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    final int length = mTextArray.length;
    mPaint.setTextSize(mTextSize);
    for (int i = 0; i < length; i++) {
        if ((i > mLeftCursorIndex && i < mRightCursorIndex) || (i == mLeftCursorIndex || i == mRightCursorIndex)) {
            mPaint.setColor(mTextColorSelected);
        } else {
            mPaint.setColor(mTextColorNormal);
        }
        final String text2draw = mTextArray[i].toString();
        final float textWidth = mTextWidthArray[i];
        float textDrawLeft = mSeekbarRect.left + i * mPartLength - textWidth / 2;
        canvas.drawText(text2draw, textDrawLeft, mPaddingRect.top + mTextSize, mPaint);
    }
    final float radius = (float) mSeekbarHeight / 2;
    mSeekbarRectSelected.left = mSeekbarRect.left + mPartLength * mLeftCursorIndex;
    mSeekbarRectSelected.right = mSeekbarRect.left + mPartLength * mRightCursorIndex;
    if (mLeftCursorIndex == 0 && mRightCursorIndex == length - 1) {
        mPaint.setColor(mSeekbarColorSelected);
        canvas.drawRoundRect(mSeekbarRect, radius, radius, mPaint);
    } else {
        mPaint.setColor(mSeekbarColorNormal);
        canvas.drawRoundRect(mSeekbarRect, radius, radius, mPaint);
        mPaint.setColor(mSeekbarColorSelected);
        canvas.drawRect(mSeekbarRectSelected, mPaint);
    }
    final int leftWidth = mLeftCursorBG.getIntrinsicWidth();
    final int leftHieght = mLeftCursorBG.getIntrinsicHeight();
    final int leftLeft = (int) (mSeekbarRectSelected.left - (float) leftWidth / 2);
    final int leftTop = (int) ((mSeekbarRect.top + mSeekbarHeight / 2) - (leftHieght / 2));
    mLeftCursorRect.left = leftLeft;
    mLeftCursorRect.top = leftTop;
    mLeftCursorRect.right = leftLeft + leftWidth;
    mLeftCursorRect.bottom = leftTop + leftHieght;
    mLeftCursorBG.setBounds(mLeftCursorRect);
    mLeftCursorBG.draw(canvas);
    final int rightWidth = mRightCursorBG.getIntrinsicWidth();
    final int rightHeight = mRightCursorBG.getIntrinsicHeight();
    final int rightLeft = (int) (mSeekbarRectSelected.right - (float) rightWidth / 2);
    final int rightTop = (int) ((mSeekbarRectSelected.top + mSeekbarHeight / 2) - (rightHeight / 2));
    mRightCursorRect.left = rightLeft;
    mRightCursorRect.top = rightTop;
    mRightCursorRect.right = rightLeft + rightWidth;
    mRightCursorRect.bottom = rightTop + rightHeight;
    mRightCursorBG.setBounds(mRightCursorRect);
    mRightCursorBG.draw(canvas);
}

Output:
         final float textWidth = mTextWidthArray[i];
-        float textDrawLeft = mSeekbarRect.left + i * mPartLength - textWidth / 2;
+        float textDrawLeft = 0;
+        if (i == length - 1) {
+            textDrawLeft = mSeekbarRect.right + (mRightCursorBG.getIntrinsicWidth() / 2) - textWidth;
+        } else {
+            textDrawLeft = mSeekbarRect.left + i * mPartLength - textWidth / 2;
+        }
         canvas.drawText(text2draw, textDrawLeft, mPaddingRect.top + mTextSize, mPaint);


Input:
public void tick() {
    executor.execute(new Runnable() {
        public void run() {
            ticksExisted.incrementAndGet();
            doTick();
        }
    });
}

Output:
 public void tick() {
-    executor.execute(new Runnable() {
-        public void run() {
-            ticksExisted.incrementAndGet();
-            doTick();
-        }
+    executor.execute(() -> {
+        ticksExisted.incrementAndGet();
+        doTick();
     });


Input:
public boolean findTarget(boolean doSet) {
    if (worldObj.isRemote) {
        return false;
    }
    boolean columnVisitListIsUpdated = false;
    if (visitList.isEmpty()) {
        createColumnVisitList();
        columnVisitListIsUpdated = true;
    }
    if (!doSet) {
        return !visitList.isEmpty();
    }
    if (visitList.isEmpty()) {
        return false;
    }
    int[] nextTarget = visitList.removeFirst();
    if (!columnVisitListIsUpdated) {
        for (int y = nextTarget[1] + 1; y < yCoord + 3; y++) {
            Block block = worldObj.getBlock(nextTarget[0], y, nextTarget[2]);
            if (BlockUtils.isAnObstructingBlock(block, worldObj, nextTarget[0], y, nextTarget[2])) {
                createColumnVisitList();
                columnVisitListIsUpdated = true;
                nextTarget = null;
                break;
            }
        }
    }
    if (columnVisitListIsUpdated && nextTarget == null && !visitList.isEmpty()) {
        nextTarget = visitList.removeFirst();
    } else if (columnVisitListIsUpdated && nextTarget == null) {
        return false;
    }
    setTarget(nextTarget[0], nextTarget[1] + 1, nextTarget[2]);
    return true;
}

Output:
             Block block = worldObj.getBlock(nextTarget[0], y, nextTarget[2]);
-            if (BlockUtils.isAnObstructingBlock(block, worldObj, nextTarget[0], y, nextTarget[2])) {
+            if (BlockUtils.isAnObstructingBlock(block, worldObj, nextTarget[0], y, nextTarget[2]) || !BuildCraftAPI.isSoftBlock(worldObj, nextTarget[0], y, nextTarget[2])) {
                 createColumnVisitList();


Input:
private JsonNode fromEntity(Entity entity) {
    ObjectNode aRoot = entityBase(entity);
    aRoot.put("String_Node_Str", entity.getApplicationId());
    if (entity.getParent() != null) {
        aRoot.put("String_Node_Str", entity.getParent().getId());
    }
    if (!entity.getGroups().isEmpty())
        aRoot.put("String_Node_Str", entitiesIdAsArray(entity.getGroups()));
    if (!entity.getChildren().isEmpty())
        aRoot.put("String_Node_Str", entitiesIdAndNameAsArray(entity.getChildren()));
    if ((entity instanceof Group) && !((Group) entity).getMembers().isEmpty())
        aRoot.put("String_Node_Str", entitiesIdAndNameAsArray(((Group) entity).getMembers()));
    return aRoot;
}

Output:
         aRoot.put("String_Node_Str", entitiesIdAndNameAsArray(entity.getChildren()));
-    if ((entity instanceof Group) && !((Group) entity).getMembers().isEmpty())
-        aRoot.put("String_Node_Str", entitiesIdAndNameAsArray(((Group) entity).getMembers()));
+    if (entity instanceof Group) {
+        Collection<Entity> members = entity.getAttribute(AbstractGroup.GROUP_MEMBERS);
+        if (members != null && !members.isEmpty())
+            aRoot.put("String_Node_Str", entitiesIdAndNameAsArray(members));
+    }
     return aRoot;


Input:
public static PackageInfo generatePackageInfo(PackageParser.Package p, int[] gids, int flags, long firstInstallTime, long lastUpdateTime) {
    PackageInfo pi = new PackageInfo();
    pi.packageName = p.packageName;
    pi.versionCode = p.mVersionCode;
    pi.versionName = p.mVersionName;
    pi.sharedUserId = p.mSharedUserId;
    pi.sharedUserLabel = p.mSharedUserLabel;
    pi.applicationInfo = p.applicationInfo;
    pi.installLocation = p.installLocation;
    pi.firstInstallTime = firstInstallTime;
    pi.lastUpdateTime = lastUpdateTime;
    if ((flags & PackageManager.GET_GIDS) != 0) {
        pi.gids = gids;
    }
    if ((flags & PackageManager.GET_CONFIGURATIONS) != 0) {
        int N = p.configPreferences.size();
        if (N > 0) {
            pi.configPreferences = new ConfigurationInfo[N];
            p.configPreferences.toArray(pi.configPreferences);
        }
        N = p.reqFeatures != null ? p.reqFeatures.size() : 0;
        if (N > 0) {
            pi.reqFeatures = new FeatureInfo[N];
            p.reqFeatures.toArray(pi.reqFeatures);
        }
    }
    if ((flags & PackageManager.GET_ACTIVITIES) != 0) {
        int N = p.activities.size();
        if (N > 0) {
            if ((flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                pi.activities = new ActivityInfo[N];
            } else {
                int num = 0;
                for (int i = 0; i < N; i++) {
                    if (p.activities.get(i).info.enabled)
                        num++;
                }
                pi.activities = new ActivityInfo[num];
            }
            for (int i = 0, j = 0; i < N; i++) {
                final Activity activity = p.activities.get(i);
                if (activity.info.enabled || (flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                    pi.activities[j++] = generateActivityInfo(p.activities.get(i), flags);
                }
            }
        }
    }
    if ((flags & PackageManager.GET_RECEIVERS) != 0) {
        int N = p.receivers.size();
        if (N > 0) {
            if ((flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                pi.receivers = new ActivityInfo[N];
            } else {
                int num = 0;
                for (int i = 0; i < N; i++) {
                    if (p.receivers.get(i).info.enabled)
                        num++;
                }
                pi.receivers = new ActivityInfo[num];
            }
            for (int i = 0, j = 0; i < N; i++) {
                final Activity activity = p.receivers.get(i);
                if (activity.info.enabled || (flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                    pi.receivers[j++] = generateActivityInfo(p.receivers.get(i), flags);
                }
            }
        }
    }
    if ((flags & PackageManager.GET_SERVICES) != 0) {
        int N = p.services.size();
        if (N > 0) {
            if ((flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                pi.services = new ServiceInfo[N];
            } else {
                int num = 0;
                for (int i = 0; i < N; i++) {
                    if (p.services.get(i).info.enabled)
                        num++;
                }
                pi.services = new ServiceInfo[num];
            }
            for (int i = 0, j = 0; i < N; i++) {
                final Service service = p.services.get(i);
                if (service.info.enabled || (flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                    pi.services[j++] = generateServiceInfo(p.services.get(i), flags);
                }
            }
        }
    }
    if ((flags & PackageManager.GET_PROVIDERS) != 0) {
        int N = p.providers.size();
        if (N > 0) {
            if ((flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                pi.providers = new ProviderInfo[N];
            } else {
                int num = 0;
                for (int i = 0; i < N; i++) {
                    if (p.providers.get(i).info.enabled)
                        num++;
                }
                pi.providers = new ProviderInfo[num];
            }
            for (int i = 0, j = 0; i < N; i++) {
                final Provider provider = p.providers.get(i);
                if (provider.info.enabled || (flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                    pi.providers[j++] = generateProviderInfo(p.providers.get(i), flags);
                }
            }
        }
    }
    if ((flags & PackageManager.GET_INSTRUMENTATION) != 0) {
        int N = p.instrumentation.size();
        if (N > 0) {
            pi.instrumentation = new InstrumentationInfo[N];
            for (int i = 0; i < N; i++) {
                pi.instrumentation[i] = generateInstrumentationInfo(p.instrumentation.get(i), flags);
            }
        }
    }
    if ((flags & PackageManager.GET_PERMISSIONS) != 0) {
        int N = p.permissions.size();
        if (N > 0) {
            pi.permissions = new PermissionInfo[N];
            for (int i = 0; i < N; i++) {
                pi.permissions[i] = generatePermissionInfo(p.permissions.get(i), flags);
            }
        }
        N = p.requestedPermissions.size();
        if (N > 0) {
            pi.requestedPermissions = new String[N];
            for (int i = 0; i < N; i++) {
                pi.requestedPermissions[i] = p.requestedPermissions.get(i);
            }
        }
    }
    if ((flags & PackageManager.GET_SIGNATURES) != 0) {
        int N = (p.mSignatures != null) ? p.mSignatures.length : 0;
        if (N > 0) {
            pi.signatures = new Signature[N];
            System.arraycopy(p.mSignatures, 0, pi.signatures, 0, N);
        }
    }
    return pi;
}

Output:
     pi.sharedUserLabel = p.mSharedUserLabel;
-    pi.applicationInfo = p.applicationInfo;
+    pi.applicationInfo = generateApplicationInfo(p, flags);
     pi.installLocation = p.installLocation;


Input:
public double getItemPrice(Player player, StockItem item, String transation, int slot, double nprice) {
    double price = nprice;
    if (item.isPatternListening()) {
        if (patternPrices.containsKey(transation))
            if (patternPrices.get(transation).containsKey(item.getIdAndData()))
                price = patternPrices.get(transation).get(item.getIdAndData());
            else
                for (Map.Entry<String, Double> entry : patternPrices.get(transation).entrySet()) if (item.getIdAndData().split("String_Node_Str")[0].equals(entry.getKey()))
                    price = entry.getValue();
        for (Map.Entry<String, TransactionPattern> tier : patternTiers.entrySet()) if (CitizensTrader.getPermissionsManager().has(player, "String_Node_Str" + tier.getKey())) {
            price = tier.getValue().getItemPrice(player, item, transation, slot, price);
        }
    } else
        price = item.getRawPrice();
    if (!item.hasStackPrice() && nprice == 0.0)
        price *= item.getAmount(slot);
    price *= multiplier.get(transation);
    return price;
}

Output:
         price = item.getRawPrice();
-    if (!item.hasStackPrice() && nprice == 0.0)
+    if (!item.hasStackPrice() && nprice == 0.0 && !tier)
         price *= item.getAmount(slot);


Input:
public void run() {
    while (this.alive) {
        IORequest<Buffer.Output> request = null;
        while (request == null) {
            try {
                request = requestQueue.take();
            } catch (InterruptedException iex) {
                if (!this.alive) {
                    return;
                }
            }
        }
        IOException ioex = null;
        try {
            request.buffer.writeToChannel(request.channel.fileChannel);
        } catch (IOException e) {
            ioex = e;
        }
        request.channel.handleProcessedBuffer(request.buffer, ioex);
    }
}

Output:
         try {
-            request.buffer.writeToChannel(request.channel.fileChannel);
+            if (!request.buffer.memory.isFree()) {
+                request.buffer.writeToChannel(request.channel.fileChannel);
+            }
         } catch (IOException e) {


Input:
public void onClick(View v) {
    switch(mAppState) {
        case unknown:
        case need_update:
        case install_failed:
        case download_failed:
            try {
                String url = UrlHelpers.getDownloadUrl(TokenWrapper.getToken(mContext), mAppInfo.mAppCode);
                Intent i = new Intent();
                i.setClass(mContext, DownloadInstallService.class);
                i.setAction(DownloadInstallService.ACTION_INSTALL_APP);
                i.putExtra(DownloadInstallService.EXTRA_HTTP_URL, url);
                i.putExtra(DownloadInstallService.EXTRA_MIME, AppInfo.MIMETYPE);
                i.putExtra(DownloadInstallService.EXTRA_APP_CODE, mAppInfo.mAppCode);
                i.putExtra(DownloadInstallService.EXTRA_APP_VERSION, mAppInfo.mAppVersion);
                i.putExtra(DownloadInstallService.EXTRA_APP_NAME, mAppInfo.mAppName);
                i.putExtra(DownloadInstallService.EXTRA_APP_IMAGE_URL, mAppInfo.mAppImageUrl);
                i.putExtra(DownloadInstallService.EXTRA_APP_AUTHOR, mAppInfo.mAppAuthor);
                i.putExtra(DownloadInstallService.EXTRA_APP_SHORTDESC, mAppInfo.mAppShortDesc);
                mContext.startService(i);
                mListener.onInstallClicked(mAppInfo);
            } catch (Throwable tr) {
                tr.printStackTrace();
            }
            break;
        case install_succeeded:
            try {
                String pkgName = PkgsProviderWrapper.getAppPkgName(mContext, mAppInfo.mAppCode);
                PackageManager pm = mContext.getPackageManager();
                Intent intent = pm.getLaunchIntentForPackage(pkgName);
                mContext.startActivity(intent);
            } catch (Throwable tr) {
                tr.printStackTrace();
            }
            break;
        case downloading:
        case download_succeeded:
        case installing:
        default:
            Log.e(TAG, "String_Node_Str");
            break;
    }
}

Output:
         case download_failed:
-            try {
-                String url = UrlHelpers.getDownloadUrl(TokenWrapper.getToken(mContext), mAppInfo.mAppCode);
-                Intent i = new Intent();
-                i.setClass(mContext, DownloadInstallService.class);
-                i.setAction(DownloadInstallService.ACTION_INSTALL_APP);
-                i.putExtra(DownloadInstallService.EXTRA_HTTP_URL, url);
-                i.putExtra(DownloadInstallService.EXTRA_MIME, AppInfo.MIMETYPE);
-                i.putExtra(DownloadInstallService.EXTRA_APP_CODE, mAppInfo.mAppCode);
-                i.putExtra(DownloadInstallService.EXTRA_APP_VERSION, mAppInfo.mAppVersion);
-                i.putExtra(DownloadInstallService.EXTRA_APP_NAME, mAppInfo.mAppName);
-                i.putExtra(DownloadInstallService.EXTRA_APP_IMAGE_URL, mAppInfo.mAppImageUrl);
-                i.putExtra(DownloadInstallService.EXTRA_APP_AUTHOR, mAppInfo.mAppAuthor);
-                i.putExtra(DownloadInstallService.EXTRA_APP_SHORTDESC, mAppInfo.mAppShortDesc);
-                mContext.startService(i);
-                mListener.onInstallClicked(mAppInfo);
-            } catch (Throwable tr) {
-                tr.printStackTrace();
-            }
+            installApp();
             break;


Input:
public void evictAll() {
    ehcache.removeAll();
}

Output:
 public void evictAll() {
-    ehcache.removeAll();
+    if (ehcache.getStatus().equals(Status.STATUS_ALIVE)) {
+        ehcache.removeAll();
+    }
 }


Input:
public boolean onOptionsItemSelected(MenuItem item) {
    switch(item.getItemId()) {
        case R.id.menu_refresh:
            RepoLoader.getInstance().triggerReload(true);
            return true;
        case R.id.menu_share:
            String text = mModule.name + "String_Node_Str";
            String s = getPackageManager().getInstallerPackageName(mPackageName);
            if (s.equals(ModulesFragment.PLAY_STORE_PACKAGE)) {
                text += String.format(ModulesFragment.PLAY_STORE_LINK, mPackageName);
            } else {
                text += String.format(ModulesFragment.XPOSED_REPO_LINK, mPackageName);
            }
            Intent sharingIntent = new Intent(Intent.ACTION_SEND);
            sharingIntent.setType("String_Node_Str");
            sharingIntent.putExtra(Intent.EXTRA_TEXT, text);
            startActivity(Intent.createChooser(sharingIntent, getString(R.string.share)));
            return true;
    }
    return super.onOptionsItemSelected(item);
}

Output:
             String text = mModule.name + "String_Node_Str";
-            String s = getPackageManager().getInstallerPackageName(mPackageName);
-            if (s.equals(ModulesFragment.PLAY_STORE_PACKAGE)) {
-                text += String.format(ModulesFragment.PLAY_STORE_LINK, mPackageName);
+            if (isPackageInstalled(mPackageName, this)) {
+                String s = getPackageManager().getInstallerPackageName(mPackageName);
+                if (s.equals(ModulesFragment.PLAY_STORE_PACKAGE)) {
+                    text += String.format(ModulesFragment.PLAY_STORE_LINK, mPackageName);
+                } else {
+                    text += String.format(ModulesFragment.XPOSED_REPO_LINK, mPackageName);
+                }
             } else {


Input:
public void update(TableView table) {
    try {
        if (table != null) {
            switch(table.getTableState()) {
                case STARTING:
                    this.btnStart.setEnabled(true);
                    this.btnMoveDown.setEnabled(true);
                    this.btnMoveUp.setEnabled(true);
                    break;
                case WAITING:
                    this.btnStart.setEnabled(false);
                    this.btnMoveDown.setEnabled(false);
                    this.btnMoveUp.setEnabled(false);
                    break;
                default:
                    closeDialog();
                    return;
            }
            int row = this.tableSeats.getSelectedRow();
            tableWaitModel.loadData(table);
            this.tableSeats.repaint();
            this.tableSeats.getSelectionModel().setSelectionInterval(row, row);
        } else {
            closeDialog();
        }
    } catch (Exception ex) {
        closeDialog();
    }
}

Output:
             switch(table.getTableState()) {
-                case STARTING:
+                case READY_TO_START:
                     this.btnStart.setEnabled(true);


Input:
private void _checkBinaryMatch(HashMap<String, String> env, Product product) throws PrqaSetupException {
    String pathSep = System.getProperty("String_Node_Str");
    if (isUnix) {
        if (product instanceof QAC) {
            File f = new File(env.get("String_Node_Str") + pathSep + "String_Node_Str");
            String path = f.getPath();
            if (!f.exists()) {
                throw new PrqaSetupException(String.format("String_Node_Str", path));
            }
        } else {
            File f = new File(env.get("String_Node_Str") + pathSep + "String_Node_Str");
            String path = f.getPath();
            if (!f.exists()) {
                throw new PrqaSetupException(String.format("String_Node_Str", path));
            }
        }
    } else {
        if (product instanceof QAC) {
            File f = new File(env.get("String_Node_Str") + pathSep + "String_Node_Str");
            String path = f.getPath();
            if (!f.exists()) {
                throw new PrqaSetupException(String.format("String_Node_Str", path));
            }
        } else {
            File f = new File(env.get("String_Node_Str") + pathSep + "String_Node_Str");
            String path = f.getPath();
            if (!f.exists()) {
                throw new PrqaSetupException(String.format("String_Node_Str", path));
            }
        }
    }
}

Output:
     String pathSep = System.getProperty("String_Node_Str");
-    if (isUnix) {
-        if (product instanceof QAC) {
-            File f = new File(env.get("String_Node_Str") + pathSep + "String_Node_Str");
-            String path = f.getPath();
-            if (!f.exists()) {
-                throw new PrqaSetupException(String.format("String_Node_Str", path));
+    if (env != null) {
+        if (isUnix) {
+            if (product instanceof QAC) {
+                File f = new File(env.get("String_Node_Str") + pathSep + "String_Node_Str");
+                String path = f.getPath();
+                if (!f.exists()) {
+                    throw new PrqaSetupException(String.format("String_Node_Str", path));
+                }
+            } else {
+                File f = new File(env.get("String_Node_Str") + pathSep + "String_Node_Str");
+                String path = f.getPath();
+                if (!f.exists()) {
+                    throw new PrqaSetupException(String.format("String_Node_Str", path));
+                }
             }


Input:
public ODocument getConfiguration() {
    return new ODocument().fromJSON("String_Node_Str" + getCommonConfigurationParameters() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
}

Output:
 public ODocument getConfiguration() {
-    return new ODocument().fromJSON("String_Node_Str" + getCommonConfigurationParameters() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
+    return new ODocument().fromJSON("String_Node_Str" + getCommonConfigurationParameters() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
 }


Input:
public void highlightConcepts(Set<Object> objects) {
    if (objects != null) {
        OntologySolver solver = (OntologySolver) getContainer();
        for (Object object : objects) {
            if (object instanceof NamedObj) {
                Concept concept = solver.getResolvedConcept(object, false);
                if (concept != null) {
                    List<ColorAttribute> colors = concept.attributeList(ColorAttribute.class);
                    if (colors != null && colors.size() > 0) {
                        ColorAttribute conceptColor = colors.get(0);
                        String request = "String_Node_Str" + "String_Node_Str" + conceptColor.getExpression() + "String_Node_Str";
                        MoMLChangeRequest change = new MoMLChangeRequest(this, (NamedObj) object, request, false);
                        ((NamedObj) object).requestChange(change);
                    }
                }
            }
        }
        solver.requestChange(new MoMLChangeRequest(this, solver, "String_Node_Str"));
    }
}

Output:
             if (object instanceof NamedObj) {
-                Concept concept = solver.getResolvedConcept(object, false);
+                Concept concept = solver.getConcept(object);
                 if (concept != null) {


Input:
public ItemStack decrStackSize(ItemStack me, int var1, int var2) {
    if (getStackInSlot(me, var1) != null) {
        ItemStack itemstack;
        if (getStackInSlot(me, var1).stackSize <= var2) {
            itemstack = getStackInSlot(me, var1);
            setInventorySlotContents(me, var1, null);
            hasPlates(me);
            return itemstack;
        } else {
            ItemStack stack2 = getStackInSlot(me, var1);
            itemstack = stack2.splitStack(var2);
            setInventorySlotContents(me, var1, stack2);
            if (getStackInSlot(me, var1).stackSize == 0) {
                setInventorySlotContents(me, var1, null);
            }
            hasPlates(me);
            return itemstack;
        }
    } else {
        return null;
    }
}

Output:
         ItemStack itemstack;
-        if (getStackInSlot(me, var1).stackSize <= var2) {
+        if (getStackInSlot(me, var1).getCount() <= var2) {
             itemstack = getStackInSlot(me, var1);


Input:
private void initializeConnection() {
    Statement stmt = null;
    Boolean tableExists = true;
    Connection con = null;
    try {
        con = dataSource.getConnection();
        stmt = con.createStatement();
        stmt.executeQuery(executionInfo.getPreparedTableExistenceCheckStatement());
    } catch (SQLException e) {
        tableExists = false;
        if (log.isDebugEnabled()) {
            log.debug("String_Node_Str" + tableName + "String_Node_Str");
        }
    }
    try {
        if (!tableExists && stmt != null) {
            stmt.executeUpdate(executionInfo.getPreparedCreateTableStatement());
        }
    } catch (SQLException e) {
        throw new ExecutionPlanRuntimeException("String_Node_Str" + e.getMessage(), e);
    } finally {
        cleanUpConnections(stmt, con);
    }
}

Output:
     try {
-        if (!tableExists && stmt != null) {
+        if (!tableExists) {
+            con = dataSource.getConnection();
+            stmt = con.createStatement();
             stmt.executeUpdate(executionInfo.getPreparedCreateTableStatement());


Input:
static public final String decrypterPattern_Redirecter_Plugin() {
    StringBuilder completePattern = new StringBuilder();
    String[] list = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    for (String pattern : list) {
        if (completePattern.length() > 0) {
            completePattern.append("String_Node_Str");
        }
        completePattern.append(pattern);
    }
    logger.finest("String_Node_Str" + list.length + "String_Node_Str");
    return completePattern.toString();
}

Output:
     StringBuilder completePattern = new StringBuilder();
-    String[] list = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
+    String[] list = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
     for (String pattern : list) {


Input:
private List<OverviewIndUIElement> wapperInput(EList<TableIndicator> indicatorTableList, IRepositoryNode parentNode) {
    List<OverviewIndUIElement> cataUIEleList = new ArrayList<OverviewIndUIElement>();
    List<IRepositoryNode> children = parentNode.getChildren();
    for (IRepositoryNode folderNode : children) {
        if (folderNode instanceof DBTableFolderRepNode) {
            List<IRepositoryNode> tableNodes = folderNode.getChildren();
            for (TableIndicator indicator : indicatorTableList) {
                boolean equals = false;
                for (IRepositoryNode tableNode : tableNodes) {
                    MetadataTable table = ((MetadataTableRepositoryObject) tableNode.getObject()).getTable();
                    String name = table.getName();
                    String tableName = indicator.getTableName();
                    equals = name.equals(tableName);
                    if (equals) {
                        OverviewIndUIElement tableUIEle = new OverviewIndUIElement();
                        tableUIEle.setNode(tableNode);
                        tableUIEle.setOverviewIndicator(indicator);
                        try {
                            if (DqRepositoryViewService.getColumns(getTdDataProvider(), (ColumnSet) table, true).isEmpty()) {
                                tableUIEle.setVirtualNode(true);
                            }
                        } catch (Exception e) {
                            log.error(e, e);
                        }
                        cataUIEleList.add(tableUIEle);
                        break;
                    }
                }
                if (!equals) {
                    OverviewIndUIElement tableUIEle = new OverviewIndUIElement();
                    tableUIEle.setOverviewIndicator(indicator);
                    tableUIEle.setVirtualNode(true);
                    cataUIEleList.add(tableUIEle);
                }
            }
        }
    }
    return cataUIEleList;
}

Output:
                         tableUIEle.setOverviewIndicator(indicator);
-                        try {
-                            if (DqRepositoryViewService.getColumns(getTdDataProvider(), (ColumnSet) table, true).isEmpty()) {
-                                tableUIEle.setVirtualNode(true);
-                            }
-                        } catch (Exception e) {
-                            log.error(e, e);
+                        if (DqRepositoryViewService.isComeFromRefrenceProject(getTdDataProvider()) && ColumnSetHelper.getColumns((ColumnSet) table).isEmpty()) {
+                            tableUIEle.setVirtualNode(true);
                         }


Input:
protected SoyExpression visitNullCoalescingOpNode(NullCoalescingOpNode node) {
    final SoyExpression left = visit(node.getLeftChild());
    if (left.isNonNullable()) {
        return left;
    }
    final SoyExpression right = visit(node.getRightChild());
    SoyType nonNullLeftType = SoyTypes.removeNull(left.soyType());
    Features features = Features.of();
    if (Expression.areAllCheap(left, right)) {
        features = features.plus(Feature.CHEAP);
    }
    if (right.isNonNullable()) {
        features = features.plus(Feature.NON_NULLABLE);
    }
    if (nonNullLeftType.equals(right.soyType())) {
        if (left.isBoxed() == right.isBoxed()) {
            return right.withSource(firstNonNull(left, right));
        }
        if (right.isBoxed()) {
            Optional<SoyExpression> unboxedRight = right.tryUnbox();
            if (unboxedRight.isPresent()) {
                return left.withSource(firstNonNull(left, unboxedRight.get()));
            }
        } else {
            final Label leftIsNull = new Label();
            final Optional<SoyExpression> nullCheckedUnboxedLeft = left.withSource(new Expression(left.resultType(), features) {
                void doGen(CodeBuilder cb) {
                    left.gen(cb);
                    cb.dup();
                    cb.ifNull(leftIsNull);
                }
            }).asNonNullable().tryUnbox();
            if (nullCheckedUnboxedLeft.isPresent()) {
                return right.withSource(new Expression(right.resultType(), features) {
                    void doGen(CodeBuilder adapter) {
                        nullCheckedUnboxedLeft.get().gen(adapter);
                        Label end = new Label();
                        adapter.goTo(end);
                        adapter.mark(leftIsNull);
                        adapter.pop();
                        right.gen(adapter);
                        adapter.mark(end);
                    }
                });
            }
        }
    }
    return SoyExpression.forSoyValue(UnknownType.getInstance(), firstNonNull(left.box().cast(SoyValue.class), right.box().cast(SoyValue.class)));
}

Output:
         if (right.isBoxed()) {
-            Optional<SoyExpression> unboxedRight = right.tryUnbox();
-            if (unboxedRight.isPresent()) {
-                return left.withSource(firstNonNull(left, unboxedRight.get()));
-            }
+            SoyExpression boxedLeft = left.box();
+            return boxedLeft.withSource(firstNonNull(boxedLeft, right));
         } else {


Input:
public void setNodeFixed(Node node, boolean fixed) {
    if (isNodeInGraph(node)) {
        node.getNodeData().setFixed(fixed);
    }
}

Output:
 public void setNodeFixed(Node node, boolean fixed) {
-    if (isNodeInGraph(node)) {
-        node.getNodeData().setFixed(fixed);
-    }
+    node.getNodeData().setFixed(fixed);
 }